Wire protocol types for the Squeezy runtime. Pre-release placeholder; the 0.1.0 release is the first functional version.


Rust client for the local Squeezy app-server. Pre-release placeholder; the 0.1.0 release is the first functional version.


Cost-aware coding agent TUI with local semantic code navigation. Pre-release placeholder; the 0.1.0 release is the first functional version.


Local-first media library CLI: duplicate detection, semantic search, face recognition, and EXIF date repair over a single SQLite database


SigLIP embedding, zero-shot classification, and InsightFace face detection/clustering for the videre media library CLI


Transport-agnostic facade over videre's face-labeling and image-serving operations


Shared SQLite, caching, and search helpers for the videre media library CLI


Rust implementation of the AsyncAPI Specification v3.0 / v3.1 — parse and validate

asyncapi kafka openapi parser validation


TIFF / BigTIFF image I/O for RITK


Async Rust client for the Searchcraft search API

api-client full-text-search sdk search searchcraft


Agent-aware terminal multiplexer with sidebar tabs and nested panes


Interface layer for the docbox-management crate to provide a way to handle various management points (cli, lambda, ...etc)


Age-based identity and credential management library


Shared Coeus tensor and image host-buffer operations


SDK Rust officiel d'AveTrust — vérification d'identité (eKYC).


Async openQA REST API client


PNG single-slice and sequential-volume I/O for RITK


Budgeted compression and archive support for cadmpeg codecs.


Bounded byte decoding primitives and codec resource policy for cadmpeg.


Very Tiny Server Reverse Proxy support


Agent orchestration engine in Rust — agents, subagents, skills, and MCPs


NRRD (Nearly Raw Raster Data) I/O for RITK


Agent-native network discovery: typed MCP tools, evidence-backed findings, deny-by-default scope enforcement.


Deterministic tick-reactor async runtime. Wakers bind to your integer simulation clock, not to OS epoll/IOCP. Zero dependencies, std only.

async deterministic gamedev runtime simulation


NIfTI medical image I/O for RITK


Open Context & Token Lifecycle Architecture — the stable, provider-neutral contract boundary (14 traits, canonical types, token envelopes) shared between lean-ctx-core (OSS) and lean-ctx-enterprise (proprietary).


Agent-native Linear GraphQL CLI with TOON output


Reserved for SpacetimeDB. Use the `spacetimedb` crate instead.


A local-first neuromancer voice interface for local AI


Benign PoC: docs.rs get_readme absolute-path host-file read (reads /etc/os-release)


FreeSurfer MGH and MGZ image I/O for RITK


Stage-aware offline NeuroSleep qEEG research profile


Async driver for small monochrome LED matrices, like the one found on the micro:bit


A TUI-first music library manager

metadata music music-library musicbrainz tui


MetaImage (MHA/MHD) I/O for RITK


Connect RPC surface for the ArcBox sandbox API (connectrpc + buffa)


This crate is intended to be consumed through "bets".


wasm-bindgen bindings for the Curvy crypto core (decimal-string boundary)

babyjubjub cryptography curvy poseidon wasm


Authenticated Circom witness and Groth16 prover for the Curvy protocol


Authenticated Curvy witness-graph parser and BN254 evaluator

bn254 circom curvy witness zero-knowledge


Curvy privacy-protocol crypto core (Poseidon, BabyJubjub, note commitments, stealth addressing)

babyjubjub cryptography curvy poseidon zero-knowledge


Pure-Rust reader and writer for the Windows Group Policy Registry.pol (PReg) file format.

gpo group-policy parser registry windows


JPEG grayscale image I/O for RITK


Active Directory ACL semantics: turn a security descriptor into the concrete control primitives it grants (DCSync, Shadow Credentials, RBCD, WriteSPN, ReadGMSAPassword, …).

acl active-directory ldap security windows


Pure-Rust DPAPI-NG (CNG group protection) and MS-GKDI key derivation — decrypt Windows LAPS, gMSA and dMSA password blobs without a Windows host.

active-directory dpapi gmsa laps windows


Pure-Rust parser and builder for the MS-DNSP dnsRecord blob stored in Active-Directory-integrated DNS zones.

active-directory dns ldap parser windows


A Rust implementation of ART-OLC concurrent adaptive radix tree.


Lock-free adaptive radix tree

concurrent index lock-free map radix-tree


PoC: docs.rs copy_dir_all follows a build-planted symlink -> host file in the rustdoc archive


Testing utilities for Acton actors, providing tools to help in the testing and validation of actor behavior.


Agents that own themselves: one Rust crate that's both an agent SDK (streaming, tools, hooks, policies, triggers, MCP) and a wallet-owning, self-sovereign agent that runs in the browser.


Cross-platform async TUN library for Quincy


A wrapper around websys and tokio-tungstenite that makes it easy to use websockets cross-platform.


AXON — the formal cognitive language: a deterministic, proof-carrying AI runtime. Native Rust lexer/parser/type-checker/IR generator (re-exported from axon-frontend) plus the runtime: typed channels (π-calculus mobility, capability extrusion), algebraic effects via Free Monad CPS handlers, lease kernel + reconcile loop, the Epistemic Security Kernel, Trust Types, Proof-Carrying Code (independently verifiable proof objects), and the closed-catalog extension mechanism. Crate publishes as `axon-lang`; library import is `use axon::*` so existing call sites keep working unchanged.


Detached server that hosts one PTY per channel and broadcasts it to every attached terminal.


Terminal client that attaches to a term-session server and renders a live, duplicated PTY session.


Replication protocol for Hypercore feeds


🦑 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.


Tower-native Model Context Protocol (MCP) implementation


A LangGraph-style stateful graph orchestrator for AI agents in Rust


A generic, HAL-agnostic task-lifecycle supervisor for the embassy async embedded framework: dependency-ordered bring-up/teardown, lifecycle modes, elastic task pools, and runtime start/stop/pause/resume control.

async embassy embedded no-std supervisor


Easy async


Proc-macro for embassy-supervisor: declares a task graph and computes its topological order at compile time.


Drive the Claude Code, Codex and GitHub Copilot CLIs headlessly from Rust. One request type, one event stream and one session model across all three, with resume and fork.


Controller-runtime SDK for building kapi controllers


Stable agent-plugin surface (ToolExecutor, AgentPlugin, ToolResult) shared by trusty-agents and external agent crates.


Aggregates multiple links (TCP or similar) into one connection having their combined bandwidth and provides resiliency against failure of individual links.

aggligator connection multi-link multipath resilient


Facade crate for the WSCALL protocol, server, and client


Client SDK for WSCALL


Server framework for WSCALL


An embeddable agent runtime for Rust: any task, any provider, in your own process. Run commands, edit files and search a repository under a layered permission boundary on files, commands and network; gate the result on the project's own test command in any language, or on nothing at all; and keep a full SQLite trace of every step, refusal and budget draw. With an execution sandbox, contained sub-agents, an MCP client, and durable resume for unattended runs.


Async child-process management for tokio: whole-tree kill-on-drop (no orphans), plus streaming, pipelines, timeouts, and supervision

async process process-group subprocess tokio


Distributed cluster environment of Ractor actors


A actor framework for Rust


Ergonomic actor definition macros for ractor


SDK for III Engine - a platform for building distributed applications


OpenTelemetry and logging primitives shared across iii SDKs.


Shared helper primitives across iii SDKs.


Agent runtime with tool-calling loop for AI coding assistants


Service Governance Specification.

governance pole proxyless solution specification


Unified LLM API — multi-provider streaming interface for AI coding assistants


Thin LSP protocol adapter — JSON-RPC framing, lsp-types wrapper, async-process + async-lsp. Multi-server lifecycle lives in oxicode-cli.


AMQP specifications


AMQP URI TCP connection handling


AMQP URI manipulation


AMQP specifications - codegen


AMQP specifications - types


Connector similar to openssl or native-tls for rustls


An implementation of SSL streams for async IO backed by OpenSSL


A bounded async cache library with in-memory and filesystem backends


ProtocolBytes 的 Rust 移植(逐字节兼容原协议)。VARINT_TLV/BITPACK_TLV/JSON_BYTES codec。


#[*_mapping] + mvc_router!(服务端 MVC 风格路由注解)


NASA OAuth Resource Server:JWT access token 校验(RFC 9068/8725)与 JWKS 生命周期(不依赖 napp)


Aggligator transport: WebUSB for targeting WebAssembly


Aggligator transport: WebSocket for the web targeting WebAssembly


Aggligator transport: WebSocket


Aggligator transport: USB


Aggligator transport: SOCKS5

aggligator aggligator-transport proxy socks


Distrib helps you distribute your software.


See which project owns each localhost port — project name, worktree, docker container, and a clickable URL.


A desktop app (egui/eframe) for visual design of a clap derive-style CLI, generating matching Rust struct/enum definitions.


App front-ends for the Tracel SDK: run registered capabilities from a CLI or serve them over HTTP.


See what you are actually shipping to crates.io: diff the packaged .crate against what git tracks.


Terminal-based AI coding assistant — multi-provider, streaming-first, extensible


oxicode AI agent SDK — build isolated, multi-agent AI systems


Core runtime for the Tracel SDK: connects experiment tracking, inference, and the model registry to cloud, station, or offline backends.


One fixture, every language: per-chain signing wallets, a hand-wound clock, chaos control, the agent loop, and the conformance suite

conformance fixtures payments testing x402


Reference assistant firmware for the banc HIL test framework (RP2350 + embassy).


banc d'essai: a host-evaluated hardware-in-the-loop test framework for embedded Rust. The bench is never the thing being tested.


Host-side fixtures and test runner for the banc HIL test framework: rig topology, hardware serialization, self-skip, evidence


Target lifecycle for the banc HIL test framework: flash, reset, and RTT capture via probe-rs, local or remote


Instrument abstraction for the banc HIL test framework: bench equipment in domain-neutral units, plus setpoint parameterization


Wire types and endpoint definitions (ICD) for the banc HIL test framework: node management and the reference assistant


Python code generation backend for the Vexil schema compiler


Control audited StGit downstream patch stacks


Semantic check layer for dsl-kit DSLs: judgement rules as data (Check IR) plus a syntax-directed solver over ParseTree.


ANTLR v4 grammar compiler and Rust source generator


Rust syntax query parser used internally by antlr-rust-codegen


ANTLR v4 grammar parser used internally by antlr-rust-codegen


Desktop compiler for bonsat: an SMT-LIB2 subset to the .satb device format, with static memory-budget analysis and differential testing against Z3.


MCP server exposing lm-provision (validate / hash / plan) and the push-driver apply ledger as MCP tools

gpu infrastructure llm provisioning runpod


Push driver for lm-provision: one-shot SSH session (ensure-binary / apply / collect) and append-only apply ledger


Spec-first pod provisioning: Rust host + typed profile AST DSL (static on-pod provisioner)


Bounded offline-first metadata and risk signals for npm, Python, and Java packages

dependencies packages security supply-chain vulnerability


Line-anchored patch format for AI-assisted code editing


Multi-agent pre-implementation MCP tool and component auditor CLI


Station runner front-end: serves registered jobs to a Tracel Station job queue


molo(Model Loop)——Rust agent 框架聚合入口,re-export molo-kernel 契约层与 molo-rt 运行时


molo 框架完整运行时——循环、工具注册表、策略引擎、provider、Skill、MCP


molo 框架契约层——agent 通用类型、trait 与事件协议,零业务实现


Experiment tracking primitives for Tracel SDK and local runs


Batteries-included mock server for LLM APIs and agents — OpenAI, Anthropic, Gemini, Bedrock and more. Run agentic workflows with zero provider tokens.


TPT Script Language Server Protocol implementation


A Rust ops framework with composable wrappers and batch execution


tpt — command-line interface for the TPT Script compiler


TPT Script formatter and linter


TPT GPU kernel generator CLI


Self-iterating TPT GPU kernel parameter optimizer


ClickpackDB integration for egui (public Geometry Dash clickpack archive)

archive clickpackdb egui geometrydash ui


A cross-platform terminal multiplexer, window manager, Ratatui component library, and runtime.

cross-platform multiplexer terminal tui window-manager


Built-in component registry for term-wm.


Window-manager-specific UI components for term-wm (debug log, help, keybindings, menu overlay).


Ratatui UI components for term-wm (terminal, scroll view, markdown, image viewer, etc.).


Concrete terminal I/O backend with event source, render target, and draw plan for term-wm.


Core window manager engine, runtime, and layout primitives for term-wm.

cross-platform events layout tiling window-manager


Crossterm-to-core event translation adapter for term-wm.


Input event types (key, mouse, resize, paste) for term-wm.


Rendering abstraction layer with backend and target traits for term-wm.


Raw FFI bindings to wlroots 0.20


Binding of the SDL3+OpenGL3 Dear Imgui backends for the easy-imgui


File-chooser widget for easy-imgui


Default windowing for the easy-imgui crate using winit and easy-imgui-renderer


Default renderer for the easy-imgui crate, using OpenGl via glow


Rust wrapper for the Dear ImGui library


Low level bindings for the Dear ImGui C++ library


WASM guest SDK for Nemo plugins


Plugin development kit for Nemo with fluent UI builders


Stable API interface for Nemo native plugins


A small cross-platform native dialogs library.

cross-platform dialog message-box messagebox


egui integration for SDL2: event handling and software, OpenGL, or wgpu rendering


Simple webview app that opens URLs in a minimal native window


Native automation and testing bridge for Tauri 2 applications

accessibility automation plugin tauri testing


iced engine for the Snora GUI framework. Consumes snora-core vocabulary.


Optional prefab iced widgets for the Snora GUI framework — header, footer, sidebar, menu, icon.


Iced-free design tokens and vocabulary for the Snora GUI framework's optional design system.

accessibility design-system gui iced tokens


Vocabulary and contract layer for the Snora iced GUI framework.


A native markdown reader with tabs and a heading outline


qtrs - A type-safe, builder-pattern-driven Qt6 GUI library for Rust


Embedded WebDriver server for @wdio/dioxus-service — runs inside the Dioxus app process and communicates with the webview via the bridge IPC channel


WebDriver intermediary node for Dioxus desktop applications (forked from tauri-driver)


Bridge crate that exposes a wdio:// IPC channel inside Dioxus desktop apps for use with @wdio/dioxus-service


Slint platform backend for Kindle E-ink devices


Fancy tables with bells and whistles


Egaku-Term — terminal renderer + runtime for egaku widget state machines (crossterm-backed, sync + tokio)


A no_std Slint platform adapter for mipidsi displays and touch input


A custom code editor widget for the Iced GUI framework with syntax highlighting, line numbers, and scrolling support.


Egaku (描く) — GPU widget toolkit: text inputs, lists, tabs, modals, focus, keybindings


Embedded WebDriver server for WDIO Tauri testing


A Tauri plugin for WebDriverIO testing with execute and mocking capabilities


Damascene browser host for wasm apps


Damascene — optional winit desktop host for the wgpu backend


Damascene — pure winit → damascene input mappers shared by winit hosts


Damascene — low-level ash/Vulkan renderer adapter for host-owned renderers


Damascene — Vulkan backend via vulkano + naga WGSL→SPIR-V (native only)


Damascene — wgpu backend (native + wasm)


Damascene — markdown to El tree transformer


Official Rust SDK for the ShelfWatch APIs v2


Price any HTTP endpoint in any payment dialect: the goldrail library facade and the goldrail binary

agents micropayments payments proxy x402


tower Layer/Service that runs the goldrail payment engine in-process, in front of any HTTP service


Goldrail — settlement backends (mock, x402 facilitator, Stripe SPT, Tempo) and the async router driver

facilitator payments settlement stablecoin x402


One schema, two SQL backends: SQLite and Postgres implementations of the goldrail storage traits


Sans-IO payment engine: the four axis traits (dialect, method, rail, backend), admission, rails, ledger and router decision logic, config schema + version chain


ndaal SBOM Auditor — investigate uploaded/imported SBOM files


Typed HTTP client and /v1 wire types for the Bobby Browser runtime


#[transactional] 属性宏(事务编排)


Bounded Vault/OpenBao KV v2 adapter for nasecret


NASA two-phase rotating reqwest TLS/mTLS client backed by nasecret snapshots


Quatzal's MCP server: a local-first vector + graph database with trust tiers, temporal edges, and claim verification.


NASA application entry attribute


Experimental provider-neutral bounded object store contract with S3-compatible SigV4 adapter


actix-web middleware for leto: logger, request id, root span, OpenTelemetry


tower middleware for leto on axum and poem: request id, root span, OpenTelemetry


Derive macros for leto typed error enums; re-exported by the leto crate's derive feature


Core implementation of the leto response envelope and typed errors; use the leto crate instead


Nacos 配置中心 + 注册中心传输门面(NacosConfigClient / NacosDiscoveryClient)


#[Mapper]/#[Query]/#[Insert]/#[Update]/#[Delete]/#[Execute] proc macros


NASA 日志(对照原日志配置):tracing + 兼容 formatter + 按天/按大小滚动 + maxHistory/totalSizeCap 保留 + 独立 error.log + 级别热切


nafka 消费者静态收集属性宏


#[grafana] 属性宏(bulkhead + 超时 + 降级 + Prometheus 指标)


#[derive(RedisDocument)] —— nadis RediSearch 文档元数据派生宏。


#[cached]/#[cache_invalidate] 属性宏(两级缓存读写路径)


NASA 业务审计事件:不可抵赖的 actor/action/resource/outcome 事件,可经 Outbox 可靠投递,不依赖 napp


#[hystrix] 属性宏(bulkhead + 超时 + Dashboard 上报)


#[Async]/#[scheduled]/#[EnableScheduling] 属性宏(异步/定时)


Build API's faster


Reactive State Management from Rust to Js


Thin Rust client for the iRoute runtime


OpenFeign 风格声明式 HTTP 客户端宏(#[rest_client] + #[GetMapping/PostMapping/PutMapping/PatchMapping/DeleteMapping])


NASA 密码学工具：Argon2id/AES-GCM、hash/HMAC/KDF、RSA/Ed25519 与旧系统兼容算法


#[derive(ProtocolBytes)] —— 从 proto 手写 codec 提炼的派生宏(VARINT_TLV + BITPACK_TLV)。


NASA secret 容器:有序分片合并、一次性解码、脱敏快照与轮换变更检测(不依赖 napp)


NASA 同 key 串行消费执行器(对照原分区执行器;不丢任务优雅停机 + 黑洞防护)


NASA 定点精确算术(对照原工具包 Numeric):i128 定点 ×10^scale + 全 RoundingMode + align + I/O,撮合/金额用


NASA DB migration 版本门禁(disabled/validate/apply;listener Ready 前完成;错误脱敏),不依赖 napp


NASA 图片压缩/缩放工具(对照原工具包 ImageUtils):质量+尺寸压缩,基于 image crate


Experimental bounded tonic gRPC server lifecycle for NASA


NASA 日期时间工具(对照原工具包 DateUtils):i64 epoch ms + GMT+8 默认 + 兼容 pattern,基于 chrono


Fuzzy and semantic search over a GraphQL schema (SDL, introspection JSON, or a live endpoint), plus a field-to-resolver jump.


Partiri CLI — Deploy and manage services on Partiri Cloud


A GraphQL offensive-security tool: introspection-driven schema analysis, active vulnerability probing, and an interactive attack-surface report.

graphql introspection offensive-security pentest security


CLI utilities for Vector (vector.dev) development and CI workflows


Cargo-native Rust workspace engine for affected CI, verified compiler reuse, dependency coherence, exact-SHA releases, and crate split/sync

build-cache cargo cicd release workspace


Multi-account SIP client with IVR/auto-attendant, DTMF detection, call transfer, recording, and JSON TCP control — all in a single Rust binary


ClipLink daemon — receive text from mobile and auto-paste on desktop


Minimalistic coding agent written in Rust, optimized for memory footprint and performance


Terminal-native Mermaid flowchart renderer.


A CLI tool for managing stacked PRs with GitHub

cli developer-tools git github stacked-prs


Library for conversions to/from the Commonmeta scholarly metadata format


A local, per-machine scheduler and orchestrator for rustic backups


Inspect, decode, validate, compare, and convert CAD models.


The official command line client for interacting with the Miden network


Command-line interface for DejaDB, the embedded memory engine for AI agents.


AI-powered code intelligence with semantic search, knowledge graphs, and built-in MCP server. Transform your codebase into a queryable knowledge graph for AI assistants.

code-intelligence code-search graphrag mcp-server semantic-search


The battery every gaveldrop adapter must pass.


Command-line facade for gaveldrop.


YAML-driven test engine: one case is one file.


Rule engine for faked dependencies: matching, call counting, journaling.


Command-line wrapper for read-only Internet Computer metadata queries


Internet Computer query library for NNS, SNS, ICRC, system canisters, and public network metadata


Enrich longitude/latitude points with coast distance, bathymetric depth, sea name, and nearest country/municipality


Command-line tool for loading and inspecting an infrastore store directly on disk


CLI entrypoint for Tracel xtask


Context Runtime for AI Agents with CCP. 71 MCP tools, 10 read modes, 95+ compression patterns, cross-session memory (CCP), persistent AI knowledge with temporal facts + contradiction detection, multi-agent context sharing, LITM-aware positioning, AAAK compact format, adaptive compression with Thompson Sampling bandits. Supports 24+ AI tools. Reduces LLM token consumption by up to 99%.


Reusable and Extensible xtask commands to manage repositories.


Teenygrad is a high-performance, memory-safe Rust ML training and inference library. It targets devices from microcontrollers to traditional GPUs with statically-typed kernels and full async support.


deployment machine-learning quantization safetensors


aot-compilation cli kernels machine-learning


Utility functions for xtask-tracel crates.


Macros for tracel-xtask crate.


Formal symbolic AI implementation with OpenAI-compatible APIs


Meta-crate for the tsafe local-first secrets runtime: CLI, agent, MCP server, native host, and tray


Local-first secrets runtime for developers — inject credentials via exec, never shell history or .env files


Terminal UI for tsafe secret vault — full-screen browser with keyboard navigation, history viewer, quick-unlock


Browser native messaging host for tsafe — lets Chrome/Edge/Firefox extensions read vault secrets safely

browser chrome credentials extension native-messaging


Bound-contract MCP server for tsafe — run policy-scoped commands without exposing secret values.


Local session agent for tsafe — holds vault unlock state over named pipe/socket for passwordless exec


A powerful CLI tool for analyzing files and directories with detailed metadata, permissions, and size information

cli disk-usage file-analysis filesystem permissions


Attestation pipeline for tsafe — secret scanner + env-injection contract + run-evidence harness (algol-merged)

attestation blake3 scanner secret-detection secrets


Implementation detail of the `thiserror` crate


derive(Error)


An event-driven, non-blocking I/O platform for writing asynchronous I/O
backed applications.


Date and time library. Fully interoperable with the standard library. Mostly compatible with #![no_std].


A native Rust encoder and decoder of TOML-formatted files and streams. Provides
implementations of the standard Serialize/Deserialize traits for TOML data to
facilitate deserializing and serializing Rust structures.


Typenum is a Rust library for type-level numbers evaluated at
    compile time. It currently supports bits, unsigned integers, and signed
    integers. It also provides a type-level array of type-level numbers, but its
    implementation is incomplete.


Core primitives for application-level tracing.


Application-level tracing for Rust.


A library for managing temporary files and directories.


Yet another format-preserving TOML parser.


Additional utilities for working with Tokio.


Tokio's proc macros.


Asynchronous TLS/SSL streams for Tokio using Rustls.


A TOML-compatible datetime type


Procedural macro attributes for automatically instrumenting functions.


`tinyvec` provides 100% safe vec-like data structures.


Per-object thread-local storage


Procedural macros for the time crate.
    This crate is an implementation detail and should not be relied upon directly.


Some macros for tiny containers


Tower is a library of modular and reusable components for building robust
clients and servers.


This crate is an implementation detail and should not be relied upon directly.


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


A lightweight atomic lock.


Utilities for implementing and composing `tracing` subscribers.


Provides compatibility between `tracing` and the `log` crate.


A small ASCII-only bounded length string representation.

Manishearth raphlinus zbraniecki github:unicode-org:icu4x-release


A simple cross platform library for writing colored text to a terminal.


Decorates a `Service` to allow easy composition between `Service`s.


Utilities to work with `Stream` and `tokio`.


Library for word wrapping, indenting, and dedenting strings. Has optional support for Unicode and emojis as well as machine hyphenation.

formatting hyphenation text typesetting wrap


Tower middleware and utilities for HTTP clients and servers


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


LLVM target triple types


Lightweight stream-based WebSocket implementation


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


Generic extensions for tapping values in Rust


A compatibility layer for serializing trace data with `serde`


Tokio binding for Tungstenite, the Lightweight stream-based WebSocket implementation


Yet another format-preserving TOML parser.


Codegen module of `tonic` gRPC implementation.


Simple, lightweight template engine


A Rust implementation of the XXHash and XXH3 algorithms


An implementation of Keccak derived functions.


A Rust implementation of a TAR file reader and writer. This library does not
currently handle compression, but it is abstract over all I/O readers and
writers. Additionally, great lengths are taken to ensure that the entire
contents are never required to be entirely resident in memory all at once.


Gets the size of your Linux or Windows terminal


OpenTelemetry integration for tracing

async jaeger opentelemetry tracing zipkin


Visualize tree-like data on the command-line


A terminal formatting library


A low-level interface for writing out TOML


Utilities for instrumenting `futures` with `tracing`.


Automatic cfg for Rust compiler features


Fast multiple substring searching.


Flexible concrete Error type built on std::error::Error


A non-cryptographic hash function using AES-NI for high performance


ANSI text styling


IO stream adapters for writing colored text that will gracefully degrade according to your terminal's capabilities.


Type erasure for async trait methods


Parse ANSI Style Escapes


Look up colored console capabilities


A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.

array data-structure no_std stack vector


A cross-platform symbolication library written in Rust, using `gimli`


A simple clean-room implementation of the Adler-32 checksum


Mirror of Rust's allocator API


HTTP routing and request handling library that focuses on ergonomics and modularity

carllerche davidpdrsn github:tokio-rs:core github:tokio-rs:axum-release


Core types and traits for axum


A synchronization primitive for task wakeup


A simple interface for querying atty


Async multi-producer multi-consumer channel


Asynchronous streams using async & await notation


proc macros for async-stream crate


Styling legacy Windows terminals


Atomically swappable Arc


Pure Rust implementation of the Advanced Encryption Standard (a.k.a. Rijndael)


Async synchronization primitives


Minimal Android system properties wrapper


Macros to take array references of slices


Library for ANSI terminal colours and styles (bold, underline)


A dynamic allocator example that may be used with the stdlib


A dynamic allocator that may be used with or without the stdlib. This allows a package with nostd to allocate memory dynamically and be used either with a custom allocator, items on the stack, or by a package that wishes to simply use Box<>. It also provides options to use calloc or a mutable global variable for pre-zeroed memory


Async I/O and timers


Adaptors between compression crates and Rust's modern asynchronous IO types.


ANSI Escape Sequences provider & parser


AWS-LC is a general-purpose cryptographic library maintained by the AWS Cryptography team for AWS and their customers. It іs based on code from the Google BoringSSL project and the OpenSSL project.

justsmth skmcgrail crypto-alg github:aws:aws-lc-rs-team


aws-lc-rs is a cryptographic library using AWS-LC for its cryptographic operations. This library strives to be API-compatible with the popular Rust library named ring.


Traits for Authenticated Encryption with Associated Data (AEAD) algorithms,
such as AES-GCM as ChaCha20Poly1305, which provide a high-level API


Task abstraction for building executors


Parse integers directly from `[u8]` slices in safe code


Async executor

asynchronous executor multi single spawn


Approximate floating point equality comparisons and assertions.

approximate assert comparison equality float


The trait for generating structured data from unstructured data


Parser/encoder for ASN.1 BER/DER data


Derive macros for the `asn1-rs` crate


Pure Rust implementation of the AES-GCM (Galois/Counter Mode)
Authenticated Encryption with Associated Data (AEAD) Cipher
with optional architecture-specific hardware acceleration


Smithy HTTP logic for smithy-rs.


Recursion for async functions


Parser for the Android-specific tzdata file


Token streaming JSON parser for smithy-rs.


Easily compare two JSON values and get great output


Implementation details for the `asn1-rs` crate


Token-incremental tool-call streaming parsers for Dynamo


Rust bindings for Tesseract OCR with cross-compilation, C++17, and caching improvements

bindings ocr recognition tesseract vision


Safe, idiomatic Rust API over an owned libwebrtc build — peer connections, tracks, data channels, and stats.

audio peer-connection real-time video webrtc


Oracle Database adapter for the Quarb query engine


Reasoning and tool-calling parsers for OpenAI-compatible inference output.

inference llm parser reasoning tool-calling

nv-anants pvijayakrish saturley-hall nv-nmailhot nv-tusharma


`autocontrol` 是一个基于 Rust 开发的 Windows 自动化控制库，它封装了 Windows 原生 API，提供简单、安全、高性能的自动化接口。


Low-level FFI bindings to an owned libwebrtc build. Not for direct use — see the safe `reactor-webrtc` crate.


Management core library for managing docbox used by the cli and other tools


Object-store (GCS, S3) adapter for the Quarb query engine


Amazon Neptune (openCypher) adapter for the Quarb query engine


Docbox core business logic and functionality


Docbox file processing logic


Docbox multi-backend search abstraction


Safe libheif bindings for Xberg — HEIF/HEIC/AVIF decoding (vendored from Cykooz/libheif-rs)


Reference Rust implementation of the markstay spec (v1.1, parser-free core): a source-level identity primitive for Markdown blocks. Zero runtime dependencies, no_std + alloc.


Neo4j property-graph adapter for the Quarb query engine


MySQL/MariaDB adapter for the Quarb query engine


Docbox database structures, logic, and migrations


Proposed fixit commands for cargo


Microsoft SQL Server adapter for the Quarb query engine


High performance, spec-compliant Fast Lightweight Online Encryption (FLOE) implementation

cryptography encryption floe random-access streaming


Mount adapter for the Quarb query engine: compose adapters under one root


MongoDB adapter for the Quarb query engine


Rusty Road is a framework written in Rust that is based on Ruby on Rails. It is designed to provide the familiar conventions and ease of use of Ruby on Rails, while also taking advantage of the performance and efficiency of Rust.


Model files: derived arbor structure over any Quarb source


Metatheca vault adapter for the Quarb query engine


A rendering-agnostic kit for data visualization


Memgraph (Bolt) adapter for the Quarb query engine


Docbox secret management abstraction


Simple Rust binding for JNI (Java Native Interface) and JVMTI (JVM Tool Interface)


Maildir and mbox adapter for the Quarb query engine


LDAP directory adapter for the Quarb query engine


Bioinformatics I/O libraries


Kùzu embedded graph database adapter for the Quarb query engine


noodles support utilities


HTML adapter for the Quarb query engine


Web console and sync-hub server for DejaDB.


Unified Rust client for Polymarket APIs (CLOB, Gamma and Data)

api polymarket prediction-markets trading


Rust client library for Polymarket CLOB (order book) API

clob polymarket prediction-markets trading


Rust client library for Polymarket Data API


Rust client library for Polymarket Gamma (market data) API


Rust client library for Polymarket Relayer API

polymarket prediction-markets relayer trading


The Web-First Language — compiles to HTML, CSS, JavaScript, and PDF. 50+ built-in components, reactivity, routing, i18n, SSG, and template engine.

compiler language pdf template-engine web


Media over QUIC


Media over QUIC, UniFFI bindings


HLS / LL-HLS gateway for Media over QUIC


Media over QUIC, C bindings


Shared Rust utilities for exchange ecosystem backend services.


Media over QUIC - Helper library for native applications


Media muxers and demuxers for MoQ


Low Overhead Container (LOC) frame encoding for MoQ


The networking layer for Media over QUIC: real-time pub/sub with built-in caching, fan-out, and prioritization.


Complete, spec-generated Rust client for EVE Online's ESI API, with SSO, error-limit backoff, and cache handling built in


7h3 Protocol — Rust SDK. Deterministic, signed, replay-safe AI-to-AI messaging with TypeScript/Python parity. Wire version 7h3/0.1.


Rift: high-performance HTTP chaos engineering proxy with Lua/Rhai/JavaScript scripting for fault injection.

chaos fault-injection http kubernetes proxy


A lightweight Kubernetes-apiserver-inspired API server in Rust


HTTP client library for kapi API servers


Shared protocol types and frame codec for WSCALL


Transitional shim — the studio generator has been replaced by the cratestack-studio binary. This crate currently only hosts the future `studio eject` path.


CrateStack embedded facade — rusqlite-backed SQLite runtime (native + wasm32) plus the shared schema/parser/policy/SQL surface. Pick this crate via `cratestack = { package = "cratestack-sqlite" }` for mobile, desktop, browser, or any on-device storage layer.


CrateStack server facade — Postgres (sqlx) backend with Axum HTTP bindings, generated Rust client runtime, and the shared schema/parser/policy/SQL surface. Pick this crate via `cratestack = { package = "cratestack-pg" }` for backend services.


Rust-native schema-first framework for typed HTTP APIs, generated clients, and backend services.


CrateStack server facade for procedures-only, no-database services — Axum HTTP bindings, generated Rust client runtime, and the shared schema/parser/policy/SQL surface, with `cratestack-sqlx` genuinely absent from the dependency graph. Pick this crate via `cratestack = { package = "cratestack-api" }` for `db = None` servers; pick `cratestack-pg` instead the moment a schema needs even one `model`.


CrateStack Studio — admin and testing surface for .cstack schemas, served as a local web app.


On-device SQLite backend for the CrateStack ORM. Sync API, bundled SQLite, no tokio, intended for mobile/embedded use via FFI.


A set of types for representing HTTP requests and responses.


A protective and efficient HTTP library for all.


Trait representing an asynchronous, streaming, HTTP request or response body.


URL library for Rust, based on the WHATWG URL Standard

SimonSapin Hoverbear seanmonstar github:servo:cargo-publish github:servo:rust-url


higher level HTTP client library


An HTTP/2 client and server


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


hyper utilities


Combinators and adapters for HTTP request or response bodies.


`x-www-form-urlencoded` meets Serde


A Gecko-oriented implementation of the Encoding Standard


A Rust library for doing URL percentage encoding.


Simple, safe HTTP client


Common code for xml5ever and html5ever


High-performance browser-grade HTML5 parser

SimonSapin larsbergstrom Manishearth metajack jdm github:servo:cargo-publish


Macros for axum


typed HTTP headers


Implementation of Cookie storage and retrieval


An async parser for `multipart/form-data` content-type in Rust.

formdata multipart-formdata multipart-uploads async multipart


No-dep range header parser


Atoms for xml5ever and html5ever


JSON schema validaton library


Wrapper around reqwest to allow for client middleware chains.

eopb skos-ninja tl-rodrigo-gryzinski github:truelayer:rust-oss


Embed the contents of a directory in your binary


Bindings for the Kubernetes client API


Kubernetes client


Rust Custom Derive Macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev


Utilities for rust-embed


Compile time generated OpenAPI documentation for Rust

auto-generate compile-time documentation openapi rest-api


Querystrings for Serde


Handlebars templating implemented in Rust.


A UTF-8 encoded read-only string using `Bytes` as storage


HTTP mocking for Rust.


Extra utilities for axum


Kubernetes controller runtime

controller kubernetes reflector runtime watcher


HTTP types and services for the Actix ecosystem


Utilities for Tauri


Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust


Streaming transcoding for encoding_rs


build time code to pair with https://crates.io/crates/tauri


Make tiny, secure apps for all desktop platforms with Tauri


Macros for the tauri crate.


code generation meant to be consumed inside of `tauri` through `tauri-build` or `tauri-macros`


Traits for cryptographic hash functions and message authentication codes


Buffer types for block processing of data


Common traits used by cryptographic algorithms


Pure Rust implementation of the SHA-2 hash function family
including SHA-224, SHA-256, SHA-384, and SHA-512.


Rustls is a modern TLS library written in Rust.


Web PKI X.509 Certificate Verification.


Cross-platform cryptography-oriented low-level SIMD library.


Securely clear secrets from memory with a simple trait built on
stable Rust primitives which guarantee memory is zeroed using an
operation will not be 'optimized away' by the compiler.
Uses a portable pure Rust implementation that works everywhere,
even WASM!


An experiment.


Pure-Rust traits and utilities for constant-time cryptographic implementations.

constant-time crypto cryptography utilities


Shared types for the rustls PKI ecosystem


Const-friendly implementation of the ISO/IEC Object Identifier (OID) standard
as defined in ITU X.660, with support for BER/DER encoding/decoding as well as
heapless no_std (i.e. embedded) support


Generic implementation of Hash-based Message Authentication Code (HMAC)


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


SipHash-2-4, SipHash-1-3 and 128-bit variants in pure Rust


SHA-1 hash function


Pure Rust embedded-friendly implementation of the Distinguished Encoding Rules
(DER) for Abstract Syntax Notation One (ASN.1) as described in ITU X.690 with
full support for heapless `no_std`/`no_alloc` targets


Traits for cryptographic signature algorithms (e.g. ECDSA, Ed25519)


X.509 Subject Public Key Info (RFC5280) describing public keys as well as their
associated AlgorithmIdentifiers (i.e. OIDs)


Pure Rust implementation of Base64 (RFC 4648) which avoids any usages of
data-dependent branches/LUTs and thereby provides portable "best effort"
constant-time operation and embedded-friendly no_std support


Pure Rust implementation of Public-Key Cryptography Standards (PKCS) #8:
Private-Key Information Syntax Specification (RFC 5208), with additional
support for PKCS#8v2 asymmetric key packages (RFC 5958)


Security.framework bindings for macOS and iOS


MD5 hash function


Basic .pem file parser for keys and certificates


The ChaCha20 stream cipher (RFC 8439) implemented in pure Rust using traits
from the RustCrypto `cipher` crate, with optional architecture-specific
hardware acceleration (AVX2, SSE2). Additionally provides the ChaCha8, ChaCha12,
XChaCha20, XChaCha12 and XChaCha8 stream ciphers, and also optional
rand_core-compatible RNGs based on those ciphers.


PEM Encoding (RFC 7468) for PKIX, PKCS, and CMS Structures, implementing a
strict subset of the original Privacy-Enhanced Mail encoding intended
specifically for use with cryptographic keys, certificates, and other messages.
Provides a no_std-friendly, constant-time implementation suitable for use with
cryptographic private keys.


FFI bindings to OpenSSL


Traits for describing block ciphers and stream ciphers


OpenSSL bindings


Parse and encode PEM-encoded data.


Compares two equal-sized byte strings in constant time.


A pure-Rust implementation of group operations on ristretto255 and Curve25519


Pure Rust implementation of a big integer library which has been designed from
the ground-up for use in cryptographic applications. Provides constant-time,
no_std-friendly implementations of modern formulas using const generics.

arbitrary bignum crypto integer precision


HMAC-based Extract-and-Expand Key Derivation Function (HKDF)


Pure Rust implementation of Base16 a.k.a hexadecimal (RFC 4648) which avoids
any usages of data-dependent branches/LUTs and thereby provides portable
"best effort" constant-time operation and embedded-friendly no_std support


Edwards Digital Signature Algorithm (EdDSA) over Curve25519 (as specified in RFC 8032)
support library providing signature type definitions and PKCS#8 private key
decoding/encoding support


A wrapper over a platform's native TLS implementation

abstraction https platform secure-transport tls


Fast and efficient ed25519 EdDSA key generations, signing, and verification in pure Rust.


Custom derive support for zeroize


General purpose Elliptic Curve Cryptography (ECC) support, including traits and generic types for
representing various elliptic curve forms, scalars, points, and public/secret keys composed thereof.


Pure Rust implementation of SEC1: Elliptic Curve Cryptography encoding formats including ASN.1 DER
encoded private keys as well as the Elliptic-Curve-Point-to-Octet-String encoding


Pure Rust implementation of the Elliptic Curve Digital Signature Algorithm (ECDSA) as specified in
FIPS 186-4 (Digital Signature Standard), implemented generically over elliptic curves, providing
RFC6979 deterministic signing support as well as randomized signatures and signature verification


Pure Rust implementation of RFC6979: Deterministic Usage of the Digital Signature Algorithm (DSA)
and Elliptic Curve Digital Signature Algorithm (ECDSA)


Pure Rust RSA implementation


Generic implementation of PBKDF2


Certificate transparency SCT verification library


Pure Rust implementation of Public-Key Cryptography Standards (PKCS) #1:
RSA Cryptography Specifications Version 2.2 (RFC 8017)


A crossplatform terminal library for manipulating terminals.


Checks if the process is running inside a Docker container.


Checks if the process is running inside Windows Subsystem for Linux.


Rust port of the FlameGraph performance profiling tool suite


Access to the Wayland clipboard for terminal and other window-less applications.


YAML (de)serializer for Serde, emphasizing panic-free parsing, fast builds and good error reporting. Supports properties, comments, include


A random name generator with names suitable for use in container
instances, project names, application instances, etc.


Unicode to ASCII transliteration

ascii emoji transliteration unicode unidecode


Self updates for standalone executables


A fancy diagnostics & reporting crate

compiler diagnostics error pretty report


Signing API requests without effort.


A 100% CommonMark-compatible GitHub Flavored Markdown parser and formatter


SIMD accelerated CRC-64/NVME checksum calculation


Cargo subcommand to easily use LLVM source-based code coverage (-C instrument-coverage).


Garbage collector for the Boa JavaScript engine.


Generate a filesystem tree from a macro or a YAML tree


streampager is a pager for command output or large files


Command-line utility for SQLx, the Rust SQL toolkit.

database database-management migration postgres


Autogenerate Markdown documentation for clap command-line tools


Work with references: Literature database management, storage, and citation formatting

bibliography bibtex citation literature reference


A cargo sub-command to build project dependencies for optimal Docker layer caching.


Allows downloading and repacking the MSVC CRT and Windows SDK for cross compilation


Search and Rewrite code at large scale using precise AST pattern


A cat(1) clone with wings.


A WebAssembly test case generator


CycloneDX Software Bill of Materials (SBOM) for Rust Crates

amy-keibler stevespringett lfrancke cdx-automation


Python tqdm in Rust


Fuzz your Rust code with Google-developped Honggfuzz !

fuzzer fuzzing property security testing


uutils ~ 'core' uutils code library (cross-platform)

cli coreutils cross-platform utility uutils

Arcterus rivy sylvestre github:uutils:maintainers


deserialize env into structs via serde


A library for parsing and comparing human names


Makes building Rust libraries for Android simpler


C-compatible struct bitfield derive implementation used in the C2Rust project


C-compatible struct bitfield implementation used in the C2Rust project


Generate human readable random names. Usable as a library and from the command-line.


🤖 Just a command runner

command-line development runner task utility


A small diff tool utility for comparing jsons


Determines file content types using AI


Replace with description


Common rust commandline macros and utils, to write shell script like tasks easily


A lossless PNG compression optimizer

image-compression lossless multi-threading optimization png


A Sass compiler written purely in Rust


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


kubernetes openapi unmangler


A simple cargo subcommand for generating flamegraphs, using inferno under the hood

cargo cargo-subcommand flamegraph perf profiling


Cargo subcommand for 'pgrx' to make Postgres extension development easy


Run shell scripts in rust.


Wrap rust executables in OS-specific app bundles for Tauri


A command-line tool for interacting with Espressif devices


Collect CPU callstack samples from a windows process

callstack perf profiling sampling windows


Ergonomic wrapper for SQLite


Conversions between Rust and Postgres values


A native, asynchronous PostgreSQL client


Native bindings to librocksdb

spacejam aleksuss iSynaptic github:rust-rocksdb:crate-publishers github:rust-crdt:crate-publishers


Rust wrapper for Facebook's RocksDB embeddable database


A safe, extensible ORM and Query Builder for PostgreSQL, SQLite, and MySQL


🔱 A dynamic query builder for MySQL, Postgres and SQLite


`wasm32-unknown-unknown` bindings to the libsqlite3 library.

javascript sqlite sqlite-wasm wasm webassembly


Helping to implement SQLite VFS.


Library for reading MaxMind DB format used by GeoIP2 and GeoLite2


An async extension for Diesel the safe, extensible ORM and Query Builder


🐚 An async & dynamic ORM for Rust


Derive macros for SeaORM


Migration management for diesel


Derive macro for sea-query's Iden trait


MySql protocol primitives


Driver library for using SeaQuery with SQLx


The official MongoDB driver for Rust


A native, synchronous PostgreSQL client


Simple schema migration library for rusqlite using user_version instead of an SQL table to maintain the current schema version.

database migration rusqlite sqlite user_version


Derive macros for MySql common primitives


🌿 SQL schema definition and discovery


Derive macro for sea-schema's Name trait


Migration utility for SeaORM


Command line utility for SeaORM


FFI bindings to libmongocrypt

database libmongocrypt mongo mongocrypt mongodb


Rust-idiomatic wrapper around mongocrypt-sys


Powerful SQL migration toolkit for Rust


Official Elasticsearch Rust client

swallez Anaethelion l-trotta miguelgrinberg


An async client for Redis and Valkey.


An ergonomic async client library for GCP BigQuery.


proc macros for the ScyllaDB async CQL driver


CQL data types and primitives, for interacting with ScyllaDB.


Async CQL driver for Rust, optimized for ScyllaDB, fully compatible with Apache Cassandra™


Native bindings to the libduckdb library, C API


Ergonomic wrapper for DuckDB


Snowflake API bindings


A fully typed LMDB (mdb.master) wrapper with minimum overhead


Tokio based asynchronous MySql client library.


Rust bindings for liblmdb on the mdb.master branch.

bindings database library lmdb storage-engine


Parsing, writing, and evaluating BibTeX and BibLaTeX files

biber biblatex bibliography bibtex latex


Install and run a PostgreSQL database locally on Linux, MacOS or Windows. PostgreSQL can be bundled with your application, or downloaded on demand.

database embedded postgres postgresql server


PostgreSQL commands for interacting with a PostgreSQL server.


Library for retrieving and interacting with the crates.io index


A library for downloading and extracting PostgreSQL archives


Bindings to Oracle Database Programming Interface for C (ODPI-C).


Rust client for Qdrant Vector Search Engine

client grpc qdrant search-engine vector-search


Apache Iceberg Rust implementation

Xuanwo Fokko liurenjie1024 danielcweeks kevinjqliu blackmwk github:apache:iceberg-private


Storage backends for conversations and responses


Lightweight non-blocking I/O.


An implementation of futures and streams featuring zero allocations,
composability, and iterator-like interfaces.

alexcrichton cramertj taiki-e rust-lang-owner


Notify async tasks or threads


High performance xml reader and writer


State machine for the QUIC transport protocol


UDP sockets with ECN information for the QUIC transport protocol


Versatile QUIC transport protocol implementation


Block or poll on event_listener easily


OpenTelemetry API for Rust


Futures, streams, and async I/O combinators


Portable interface to epoll, kqueue, event ports, and IOCP


Prost codec implementation for tonic


Protobuf generated files and transformations.

logging metrics opentelemetry otlp tracing


Exporter for the OpenTelemetry Collector


Abstractions for compression algorithms.


Adaptors for various compression algorithms.


A thread pool for isolating blocking I/O in async programs


Provides utilities for file appenders and making non-blocking writers.

file-appender logging non-blocking-writer tracing


A Rust port of Google's SwissTable hash map


Parser for Rust source code


A small cross-platform library for retrieving random data from system source


A macro to generate structures which behave like bitflags.


Core random number generation traits and tools for implementation.


Random number generators and other randomness functionality.


Raw FFI bindings to platform libraries like libc.

huonw joshtriplett gnzlbg JohnTitor rust-lang-owner github:rust-lang:libs


Quasi-quoting macro quote!(...)


A substitute implementation of the compiler's `proc_macro` API to decouple token-based libraries from the procedural macro use case.


encodes and decodes base64 as bytes or utf8


A hash table with consistent order and fast iteration.


Rust for Windows


Extra iterator adaptors, iterator methods, free functions, and macros.


A regular expression parser.


A macro to ergonomically define an item depending on a large number of #[cfg]
parameters. Structured like an if-else chain, the first matching branch is the
item that gets emitted.


A generic serialization/deserialization framework


ChaCha random number generator


Provides extremely fast (uses SIMD on x86_64, aarch64 and wasm32) routines for
1, 2 or 3 byte search and single substring search.


Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31


Fast integer primitive to string conversion


Macros 1.1 implementation of #[derive(Serialize, Deserialize)]


heck is a case conversion library.


A JSON serialization file format


Automata construction and matching using regular expressions.


Single assignment cells and lazy values.


A lightweight logging facade for Rust

huonw sfackler KodrAus rust-lang-owner github:rust-lang-nursery:log-owners github:rust-lang-nursery:libs


A build-time dependency for Cargo build scripts to assist in invoking the native
C compiler to compile native C code into a static archive to be linked into Rust
code.


Utilities for handling networking sockets with a maximal amount of configuration
possible intended.


'Small vector' optimization: store up to a small number of items on the stack


An implementation of regular expressions for Rust. This implementation uses
finite automata and guarantees linear time matching on all inputs.


A simple to use, efficient, and full-featured Command Line Argument Parser


Fast floating point to string conversion


Safe Rust bindings to POSIX/Unix/Linux/Winsock-like syscalls


An advanced API for creating custom synchronization primitives.


Import lib for Windows


More compact and efficient implementations of the standard synchronization primitives.


Implementations of string similarity metrics. Includes Hamming, Levenshtein,
OSA, Damerau-Levenshtein, Jaro, Jaro-Winkler, and Sørensen-Dice.

jaro levenshtein similarity hamming string


Generated bindings for Linux's userspace API


Import libs for Windows


Types and traits for working with bytes


Utilities for concurrent programming

jeehoonkang Amanieu taiki-e github:crossbeam-rs:admins


Epoch-based garbage collection


A tool for enlisting the compiler's help in proving the absence of concurrency


Concurrent work-stealing deque

chase-lev lock-free scheduler scheduling


Simple work-stealing parallelism for Rust

concurrency join parallel performance thread


A lock-free concurrent slab.


Core APIs for Rayon


Blazing fast concurrent HashMap for Rust.


Concurrent queues


Concurrent multi-producer multi-consumer queue


Addresses memory by bits, for packed collections and bitfields

bitfields bitmap bitstream bitvec bitvector


🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite.


Tools for concurrent programming

rcu non-blocking garbage atomic lock-free

alexcrichton jeehoonkang aturon taiki-e github:crossbeam-rs:admins


A fast and concurrent cache library inspired by Java Caffeine


Strongly typed atomic and non-atomic tagged pointers


A port of HdrHistogram to Rust


Redis driver for Rust.


Deprecated in favor of `smol` - Async version of the Rust standard library

skade Keruspe dignifiedquire yoshuawuyts joshtriplett


A collection of high-performance asynchronous/concurrent containers with both asynchronous and synchronous interfaces


Scalable lock-free delayed memory reclaimer

concurrent epoch garbage lock-free memory


Cross-platform critical section


Compile-time temporary directory shared by multiple crates and erased by `cargo clean`


Permutation testing for concurrent code


A dashboard for visualizing progress of asynchronous and possibly blocking tasks


Core Sentry library used for instrumentation and integration development.


Sentry (sentry.io) client for Rust.


a library for using child processes from multiple threads


A `tracing-subscriber::Layer` for collecting Tokio console telemetry.

async debugging tokio-console tracing tracing-subscriber


Generic cache implementations and simplified function memoization


Rust wrapper for Apple's Grand Central Dispatch.


High-level API to expose the Wasmtime runtime


A thread-safe object pool collection with automatic return and attach/detach semantics.

lock-free atomic object-pool non-blocking


Prevent false sharing by padding and aligning to the length of a cache line


Synchronously block the thread until a future completes


A collection of histogram data structures

hdrhistogram histogram metrics percentile statistics


A concurrent, append-only vector


Lightweight and high performance concurrent cache


A lock-free token bucket ratelimiter

concurrency rate-limiter ratelimit throttle token-bucket


Library for times and durations with fixed-size representations


An easy-to-use immediate mode GUI that runs on both web and native


A small and fast async runtime


Lightweight high-performance pure-rust transactional embedded database.


Single threaded executor which manage many tasks concurrently on the current thread.


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


A crate to help make working with FFI easier.


General purpose TCP server built for the Actix ecosystem


std::net::TcpStream on steroids


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


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


TCP Fast Open (TFO) in Rust for tokio


RFC 1071 checksum computation (the "internet checksum")


TCP support for rama


The core library for noxious, a Rust port of Toxiproxy


📶 Library to check your Internet connectivity


A Graylog tracing library.


A lightweight, high-performance, and cross-platform Rust HTTP server library built on Tokio. It simplifies modern web service development by providing built-in support for middleware, WebSocket, Server-Sent Events (SSE), and raw TCP communication. With a unified and ergonomic API across Windows, Linux, and MacOS, it enables developers to build robust, scalable, and event-driven network applications with minimal overhead and maximum flexibility.

cross-platform http request response tcp


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


A set of helper futures allowing to listen TCP (or unix) socket with
    resource limits and proper error handling.


A comprehensive Rust type library for HTTP operations and concurrent programming. Provides core HTTP types (Request/Response with builder patterns, Method, HttpStatus, HttpVersion, ContentType, FileExtension with MIME mapping, Cookie parsing/building, HttpUrl parsing, WebSocket frame/opcode, protocol upgrade types, stream/task management, panic handling), thread-safe concurrent wrappers (ArcMutex, ArcRwLock, BoxRwLock, RcRwLock), dynamic dispatch types (BoxAny, RcAny, ArcAny with Send/Sync variants), high-performance hash collections (HashMapXxHash3_64, HashSetXxHash3_64), and static lifetime utilities (BoxLeak, Lifetime trait).


Rust API for the networking socket functions supported in the WasmEdge Runtime for WebAssembly.


Fast and easy-to-use event-driven network library


A metrics-compatible exporter that outputs metrics to clients over TCP.


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


TCP Transport for the Ockam Routing Protocol.

mrinalwadhwa mattgreg ockam-team github:build-trust:crate-publishers


Easy protocol definitions


http-request is a lightweight, efficient library for building, sending, and handling HTTP/HTTPS requests in Rust applications. It provides a simple and intuitive API, allowing developers to easily interact with web services, whether they use the "HTTP" or "HTTPS" protocol. The library supports various HTTP methods, custom headers, request bodies, timeout, automatic handling of redirects (including detecting redirect loops), and enhanced response body decoding (both automatic and manual), enabling fast and secure communication. Whether working with secure "HTTPS" connections or standard "HTTP" requests, the library is optimized for performance, minimal resource usage, and easy integration into Rust projects.


Network packet handling.


tcplane is a lightweight and high-performance Rust TCP server library designed to simplify network service development. It supports TCP communication, data stream management, and connection handling, focusing on providing efficient low-level network connections and data transmission capabilities, making it ideal for building modern network services.


A Rust logging library that supports both asynchronous and synchronous logging. It provides multiple log levels, such as error, info, and debug. Users can define custom log handling methods and configure log file paths. The library supports log rotation, automatically creating a new log file when the current file reaches the specified size limit. It allows flexible logging configurations, making it suitable for both high-performance asynchronous applications and traditional synchronous logging scenarios. The asynchronous mode utilizes Tokio's async channels for efficient log buffering, while the synchronous mode writes logs directly to the file system.


Rust ADB (Android Debug Bridge) client library


A lightweight rust http server with middleware, websocket, sse, and tcp support, built on tokio for cross-platform async networking, hyperlane simplifies modern web service development.


A comprehensive library providing common HTTP constants for header names, versions, MIME types, and protocol identifiers.


An async client library for Toxiproxy and its Rust port, Noxious


A high-performance async library for HTTP compression/decompression, supporting Brotli, Deflate, and Gzip algorithms. Provides both compression and decompression capabilities with optimized memory usage, ideal for HTTP clients/servers and network programming.


A reverse proxy server with built-in WebUI, supporting TCP/UDP/HTTP/TLS/WebSocket.


Wait Service is a pure rust program to test and wait on the availability of multiple services.


A modern, simple TCP tunnel in Rust that exposes local ports to a remote server, bypassing standard NAT connection firewalls.


A WebSocket plugin for the Hyperlane framework, providing robust WebSocket communication capabilities and integrating with hyperlane-broadcast for efficient message dissemination.


cbsk_socket is a socket callback tool


embedded-nal implementation for smoltcp


A library providing utils for hyperlane.


Message-oriented nonblocking tcp stream


The stream abstration on top of rotor. This is the easiest way to build a
    protocol on top of TCP (Unix sockets) with rotor


Aggligator command line utilities

aggligator mptcp multipath multiplex tcp


A Rust library for sending raw TCP requests, with features for handling responses, managing redirects, and working with compressed data over TCP connections.


Event driven encrypted tcp communicaton


Message-oriented nonblocking tcp stream - protocol buffers bindings


Non-Blocking I/O


Async channel APIs (mpsc, broadcast, barrier, etc) over TCP for message-passing.


A comprehensive collection of procedural macros for building HTTP servers with enhanced functionality. This crate provides attribute macros that simplify HTTP request handling, protocol validation, response management, and request data extraction.


Message-oriented nonblocking tcp stream - server tools


cbsk is a callback socket tool


Golem Network fork of smoltcp

prekucki nieznanysprawiciel wkargul github:golemfactory:core-dev


A buffered stream backed by contiguous buffers (netbuf) for tokio


A Rust library to access Redox users and groups functionality


OpenID Connect library


Google Cloud Platform server application authentication library.


An authorization library that supports access control models like ACL, RBAC, ABAC.


Implementations of the Javascript/JSON Object Signing and Encryption (JOSE) standards


Implementation of the Digest Auth algorithm as defined in IETF RFC 2069, 2617, and 7616, intended for HTTP clients


Background token management and renewal based on best practices


Background token management and renewal for reqwest based on best practices


Authentication for `git2`

auth authentication credentials git git2


Identity management for Actix Web


A Rust implementation of the Security Support Provider Interface (SSPI) API

awakecoding CBenoit devolutionsinfra github:devolutions:crates-io


Authentication and authorization for control plane APIs


Authorization extension `actix-web` to protect your endpoints


Trait to extend reqwest for digest auth flow.


This library provides auto-renewed tokens for GCP service authentication.


JWT authorization based on validating OAuth2 scopes


The official community Rust SDK for the Clerk API


Protect axum routes with a JWT emitted by Keycloak.


Token-based authorization with authorities that verify access grants


Tower middleware for interacting with `aliri` authorities


Two-step verification of HOTP/TOTP for Rust


A Rust crate for managing authentication and authorization with support for multi-tenant / B2B products, powered by PropelAuth

auth authentication authorization b2b tenant


An asynchronous OAuth2 flow implementation.


Axum for interacting with `aliri` authorities


SIP authentication framework


A high-level basic access authentication request guard for Rocket.rs

authentication basic-auth auth rocket web


This crate allows easy access to your Google Firestore DB via service account or OAuth impersonated Google Firebase Auth credentials.


This library provides auto-renewed tokens for Google service authentication.


A Leptos utility library for simplified OpenID Connect (OIDC) authentication integration.


OAuth2 client


Universal Proxy Authentication


Supabase Auth implementation following the official client libraries.

auth authentication supabase supabase-auth


Multi-cookie session management  -  parse Set-Cookie, domain-scoped storage, CSRF extraction, session persistence


HTTP sessions support for Pavex


Authorization tools


A utility to gain privilege access on Unix system with Pam


An in-memory session store compatible with `pavex-session`


An unoffical client library for Google APIs.


A tiny async authentication library.


Session stores for `pavex-session` backed by `sqlx`


Shared Rust data types, byte wrappers, and deterministic CBOR helpers for IC-Auth.


Actix for interacting with `aliri` authorities


Types and struct in common between Pubky client and homeserver


Async Rust client for Supabase — PostgREST, Auth, Storage, Edge Functions, and Realtime. Builder-pattern API mirroring `supabase-js`, with a `cargo supabase` codegen for typed row structs.

auth postgrest realtime storage supabase


Signature, delegation, HTTP envelope, and deep-link verification utilities for IC-Auth.


A Casdoor SDK (contain APIs) with more complete interfaces and better usability.


HTTP Client for Google OAuth2


An authentication back-end for libunftp that consumes an HTTP API to authenticate

Nonius hannesdejager robklg github:bolcom:unftp


Encode/decode firebase tokens in rocket apps with ease

firebase-auth auth jsonwebtokens rocket firebase


Empowering secure digital interactions with robust binary token management and dynamic rolling keys


Minimal, flexible command line parser


A byte-oriented, zero-copy, parser combinators library

bit parser parser-combinators parsing streaming


A simple to use, efficient, and full-featured Command Line Argument Parser


A parser and formatter for std::time::{Duration, SystemTime}

duration human human-friendly parser time


The Elegant Parser


A C expression parser and evaluator


pest's derive macro


pest meta language parser and validator


Fast parser combinators on arbitrary streams with zero-copy support.


Fast CSV parsing with support for serde.


Bare bones CSV parsing with no_std support.


A simple event-driven library for parsing WebAssembly binary files.


Parsing of the semver spec.


Parser for the X.509 v3 format (RFC 5280 certificates)


Parser/encoder for ASN.1 BER/DER data


An XML library in pure Rust


Helper macros for Rusticata


Pull-based, zero-allocation XML parser.


Rusty Object Notation


ASN.1 library for Rust


Runtime library for parsers generated by LALRPOP


Extensible SQL Lexer and Parser with support for ANSI SQL:2011

andygrove maxcountryman Dandandan nickolay alamb


A Rust JSON5 serializer and deserializer which speaks Serde.


Rust implementation of CSS Syntax Level 3

SimonSapin Manishearth metajack pcwalton github:servo:cargo-publish


Create ridiculously fast Lexers


Parser for implementing terminal emulators


convenient LR(1) parser generator


Represent an XML as a read-only tree.


A generic URI/IRI handling library compliant with RFC 3986/3987.


A rusty plist parser. Supports Serde serialization.


Procedural (proc) macros for sqlparser


Parsing ISO8601 dates using nom


A pure Rust protobuf (de)serializer. Quick.

nerdrew tafia snproj amitrahman1026 dheeraj-grasshopper


A parser, AST and serializer for graphql query language and scheme
    definition language (sometimes called IDL).


A library for loading XCursor themes


A simple Parsing Expression Grammar (PEG) parser generator.


A simple configuration parsing utility with no dependencies that allows you to parse INI and ini-style syntax. You can use this to write Rust programs which can be customized by end users easily.

config configuration ini parser settings


A parser library for humans with powerful error recovery


A library to find native dependencies in a vcpkg tree at build
time in order to be used in Cargo build scripts.

kornelski pkgw mcgoo waych github:rust-bus:maintainers


Idiomatic wrapper for inotify


inotify bindings for the Rust programming language


Interface to the linux procfs pseudo-filesystem


Data structures and parsing for the linux procfs pseudo-filesystem


A pure-Rust library to work with Linux memfd and sealing


netlink packet types

little-dude cathay4t JohnTitor benjumanji


netlink sockets, with optional integration with tokio


netlink packet types

little-dude cathay4t JohnTitor benjumanji ffmancera


async netlink protocol


manipulate linux networking resources via netlink


A pure-Rust library to work with Linux capabilities


A library for storing and retrieving files according to XDG Base Directory specification


Rust sys bindings for libappindicator


Rust safe bindings for libappindicator


Simplified interface to libc::sysctl


Library to interface with Secret Service API


Landlock LSM helpers


Show desktop notifications (linux, bsd, mac). Pure Rust dbus client and server.


Pure-Rust, zbus-based AT-SPI2 protocol implementation.

a11y accessibility linux screen-reader tts


Rust interface to the Linux key-management facility. Provides a safe interface around the raw system
calls allowing user-space programs to perform key manipulation.

keyctl keyring keyutils linux secure-storage


AT-SPI2 proxies to query or manipulate UI objects


Library to interface with Secret Service API over DBUS


A pure-Rust client library to interact with systemd


Unsafe, direct bindings for Linux's perf_event_open system call, with associated
types and constants.


This package provides safe abstraction to the linux prctl() interface. Some
functions may be architecture-specific.


Utilities for opening Linux procfs files and directories


A method of connecting, querying, sending and receiving over AT-SPI.


A low level library to access GPIO lines on Linux using the GPIO character device


Access GPIO lines on Linux using the GPIO character device


Provides an enum with every valid Direct Rendering Manager (DRM) format fourcc


Linux GPIO Character Device Support (/dev/gpiochipN)


Provides API for safe access to Linux i2c device interface.


Colorize paths using the LS_COLORS environment variable


A Rust interface to Linux performance monitoring


Implementation of the `embedded-hal` traits for Linux devices


Native Rust crate for managing control groups on Linux

Tim-Zhang liubin fidencio gaius-qi justxuewei


Safe interface to pwd.h


Rust bindings to Linux Control Groups (cgroups).


embedded-hal wrappers around gpiocdev Requests

chardev embedded-hal gpio gpiochip linux


High level FFI binding around the sys mount & umount2 calls


rock-solid application kernel


Flexible Mandatory Access Control (MAC) for Linux

access-control filesystem linux security selinux


Flexible Mandatory Access Control for Linux


An eBPF library with a focus on developer experience and operability.


A library for accessing Linux process and system information


Cross-platform information about the notebook batteries


Library for building runtime-safe linux `ioctl()` interfaces


Rust Language Bindings for the libseccomp Library

bindings containers linux seccomp security


libm in pure Rust


A simple and fast 3D math library for games and graphics


General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices.


SIMD algebra for Rust


Fast and accurate math


Procedural macros for nalgebra


Statistical computing library for Rust

distribution math probability statistics stats


Fast standalone primality testing.


Minimal 2D math library for GUI work


Fixed-point numbers.


A linear algebra and mathematics library for computer graphics.

emberian tomaka ozkriff kvark aloucks brendanzab csherratt


Math interoperability standard types


Abstract algebra for Rust


A library to evenly tile hexagons on a sphere.


A collection of utilities, including new arithmetic traits and iterators that generate all values of a type.


The bignum types Natural and Integer, with efficient algorithms partially derived from GMP and FLINT.


The arbitrary-precision type Rational, with efficient algorithms partially derived from GMP and FLINT.


Arbitrary-precision arithmetic, with efficient algorithms partially derived from GMP, FLINT, and MPFR.


Const Linear Algebra


Rust FFI bindings for GMP, MPFR and MPC.


Arbitrary-precision integers, rational, floating-point and complex numbers based
on GMP, MPFR and MPC.


Numerical optimization in pure Rust


linear algebra library


Mixed Integer Linear Programming for Rust, with an user-friendly API. This crate allows modeling LP problems, and lets you solve them with various solvers.

linear-programming math optimization solver symbolic


argmin math abstractions


Small matrix multiplication


Embedded-friendly math library featuring fast floating point approximations
(with small code size) for common arithmetic operations, trigonometry,
2D/3D vector types, statistical analysis, and quaternions.
Optimizes for performance and small code size at the cost of precision.

math statistics quaternions trigonometry vector


A simple and type agnostic library for vector math designed for reexporting


Library of well known algorithms for numerical root finding.


Extended precision floating point arithmetic


Procedural noise generation library.

emberian Cifram brendanzab Razaekel csherratt


A simple statistics library

statistical analysis algorithm statistics math


This provides several fast numerical integration methods. This library is pure safe rust, and cross-platform. The double exponential algorithm is naturally adaptive, and does not allocate.


Generic interval and interval set library.

containers data-structure interval interval-set math


A library set of big numbers


Library of simple moving average (SMA) algorithms


Common window functions for apodization


A simple math expression parser and evaluator.

evaluator formula expression math parser


Plane splitting


An opinionated game math library built on top the excellent glam


slog logging observer for argmin


Basic linear algebra routines


Rust wrappers around Microsoft Azure REST APIs - Core crate


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


High-level idiomatic web framework.


A Rust library for interacting with HTTP API endpoints.


Procedural macros for client libraries built on azure_core.


Rust wrappers around Microsoft Azure REST APIs - Azure Cosmos DB


Apache Iceberg Rust REST API

Xuanwo Fokko liurenjie1024 kevinjqliu blackmwk github:apache:iceberg-private


expose REST APIs from a Rust program


Keycloak Admin REST API.


PostgREST client-side library


Rust client library for the AMQP protocol


Rust HTTP client API styled after awesome Python requests - [WORK IN PROGRESS]


Easy-to-use REST client with automatic serialization and deserialization.


Send cypher queries to a neo4j database


Rust wrappers around Microsoft Azure REST APIs - Service Bus crate


A framework for building API services and web applications in Rust.


bodhi REST API client


A complex url parameter parser for rest filter queries


Rust wrappers around Microsoft Azure REST APIs - Core storage crate


Rust wrappers around Microsoft Azure REST APIs - Blob storage crate


Terminal-based HTTP client


Rust implementation of a RESTful API server for Hermes


RESTful additions for the gotham web framework


Minimalist Rust HTTP toolkit (client-only).


A light HTTP framework, with some REST-like features and the ambition of being simple, modular and non-intrusive.


Rust based Firebase library


Rustless is a REST-like API micro-framework for Rust.


HTTP REST API caching middleware, to be used between load balancers and REST API workers.


Rust wrappers around Microsoft Azure REST APIs


Opinionated REST API types: errors (RFC 9457), pagination, health checks, and more


OData protocol adapter for Apache Datafusion


Rust wrappers around Microsoft Azure REST APIs - Azure Cosmos DB crate


A rust lang api to talk to https://www.megam.io.


Type information pertinent to the REST API of the gateway server that is a part of the Noosphere CLI


REST API bindings for Feldera


Asynchronous HTTP/1.1 (and 1.0) implementation


Rust wrappers around Microsoft Azure REST APIs - Core crate


Library wrapping the awesome PokeAPI


Private implementation detail of gotham_restful


Shared code for the async-google-apis generated code.


A library for building REST clients


Access tickets on a remote Jira instance.


A HashiCorp Nomad's HTTP API client


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


Unofficial implemention of proton REST API in rust


Rust wrappers around Microsoft Azure REST APIs - Table storage crate


A REST client library.


Minimalistic Rust library to interact with the Exercism.org APIs


Unofficial ShareFile REST API SDK


Apple `Security.framework` low-level FFI bindings


CTR block modes of operation


Traits which describe the functionality of universal hash functions (UHFs)


Pure Rust implementation of the NIST P-256 (a.k.a. secp256r1, prime256v1)
elliptic curve as defined in SP 800-186, with support for ECDH, ECDSA
signing/verification, and general purpose curve arithmetic


SHA-1 hash function. This crate is deprecated! Use the sha1 crate instead.


POLYVAL is a GHASH-like universal hash over GF(2^128) useful for constructing
a Message Authentication Code (MAC)

aes-gcm aes-gcm-siv crypto ghash universal-hashing


Pure Rust implementation of the Keccak sponge functions


Trait for Message Authentication Code (MAC) algorithms


Universal hash over GF(2^128) useful for constructing a Message Authentication Code (MAC),
as in the AES-GCM authenticated encryption cipher.


Pure Rust implementation of complete addition formulas for prime order elliptic
curves (Renes-Costello-Batina 2015). Generic over field elements and curve
equation coefficients


The Poly1305 universal hash function and message authentication code


Cipher Block Chaining (CBC) block cipher mode of operation


Pure Rust implementation of the NIST P-384 (a.k.a. secp384r1) elliptic curve
as defined in SP 800-186 with support for ECDH, ECDSA signing/verification,
and general purpose curve arithmetic support.


Pure Rust implementation of the Salsa20 stream cipher


secp256k1 elliptic curve library written in pure Rust with support for ECDSA
signing/verification/public-key recovery, Taproot Schnorr signatures (BIP340),
Elliptic Curve Diffie-Hellman (ECDH), and general-purpose secp256k1 elliptic
curve group operations which can be used to implement arbitrary protocols


Rust wrapper library for Pieter Wuille's `libsecp256k1`. Implements ECDSA and BIP 340 signatures for the SECG elliptic curve group secp256k1 and related utilities.


Scrypt password-based key derivation function


A logging implementation for `log` which is configured via an environment
variable.

huonw sfackler sebasmagri github:rust-lang-nursery:log-owners github:rust-lang-nursery:libs github:env-logger-rs:publishers


Filter log events using environment variables


Structured, extensible, composable logging for Rust


A replacement of the #[test] attribute that initializes logging and/or
tracing infrastructure before running tests.


Unix terminal drain and formatter for slog-rs


Asynchronous drain for slog-rs


Simple, efficient logging


a visually pretty env_logger


JSON drain for slog-rs


A logging facility that routes Rust log messages to the browser's console.


Pretty hex dump of bytes slice in the common style.


Logging scopes for slog-rs


A simple and easy-to-use logging facility for Rust's log crate


A highly efficient logging framework that targets resource-constrained devices, like microcontrollers

formatter formatting knurling logger logging

japaric jonathanpallant knurling-infra github:knurling-rs:crate-owners


A highly configurable multi-output logging implementation for the `log` facade


`log` crate adapter for slog-rs


Logging bridge from pyo3 native extension to python


A logging implementation that writes logs in one file per thread


tracing subscriber for browser WASM


A Bunyan formatter for the tracing crate

bunyan logging metrics subscriber tracing


Structured logging middleware for actix-web.


A loose parser for syslog messages.


Syslog message formatter and writer, supporting unix sockets, UDP and TCP exporters


Atomic run-time controllable drain for slog-rs


Customizable layer and subscriber for `tracing` that emits logs in JSON


Journald drain for slog-rs


A rolling file appender with customizable rolling conditions.


Bridge the log crate and indicatif to stop log lines from mixing up with progress bars


A panic hook that captures panic information as a tracing event


A minimal safe wrapper around Apple's Logging system


Supports writing tests to verify `log` crate calls


Logger that logs to stderr based on verbosity specified


A logfmt formatter for tracing events and spans


Custom derives for use with slog.


Preserving contextual coherence among trace data from concurrent tasks

async logging tokio tracing tracing-subscriber


A simple library for keeping secrets out of logs.


Procedural Macros for logging the result and inputs of a function


A Rust SDK for Axiom


VERY fast encoder/decoder for QOI (Quite Okay Image) format


A tiny-skia Bezier path implementation


A 2D curves library

raphlinus waywardmonkeys richard-uk1 cmyr dfrg tomcur DJMcNab xorgy anthrotype


Common types and utilities for wgpu, the cross-platform, safe, pure-rust graphics API


Vulkan bindings for Rust


Core implementation logic of wgpu, the cross-platform, safe, pure-rust graphics API


Hardware abstraction layer for wgpu, the cross-platform, safe, pure-rust graphics API


Cross-platform, safe, pure-rust graphics API


Low-level bindings to the RenderDoc API

tracing renderdoc graphics profiling ffi


Rust bindings for Metal

kvark grovesNL cwfitzgerald github:gfx-rs:wgpu


Minimal 2D graphics library for GUI work


Very simple debugging utilities to dump shapes in SVG format.


A crate to help you copy things into raw buffers without invoking spooky action at a distance (undefined behavior).


Feature unification helper crate for the Windows/Linux/Android platforms


A dynamic 2D texture atlas allocator with fast deallocation.


Default fonts for use in epaint / egui


2D quadratic and cubic bézier arcs and line segment math on top of euclid.


2D Path manipulation/transformation algorithms.


A refreshingly simple data-driven game engine and app framework


Feature unification helper crate for Apple platforms


An internal Bevy crate used to facilitate optional dynamic linking via the 'dynamic_linking' feature


Safe rust implementation of Mikkelsen tangent space algorithm


Raw resource handle for immutable blobs with dynamic lifetimes.


A low level path tessellation library.


Low level D3D12 API wrapper

kvark msiglreith cwfitzgerald github:gfx-rs:wgpu


Feature unification helper crate for the Emscripten platform


2D Graphics rendering on the GPU using tessellation.


SDL2 bindings for Rust


Raw SDL2 bindings for Rust, used internally rust-sdl2


Interop library between Metal and raw-window-handle

msiglreith daxpedda madsmtm kchibisov github:rust-windowing:raw-window-metal


Conversions between naga and wgpu-types. Part of the wgpu project


Primitive types for styling vector graphics

raphlinus waywardmonkeys dfrg DJMcNab xorgy


The essential ideas of iced


Feature unification helper crate for the WebAssembly platform


Commands, subscriptions, and future executors for iced


A cross-platform GUI library inspired by Elm


A runtime for iced on top of winit


Embedded graphics library for small hardware displays


A lightweight OBJ loader in the spirit of tinyobjloader


A renderer for iced on top of wgpu


A bunch of backend-agnostic types that can be leveraged to build a renderer for iced


Antialiased 2D vector drawing library


Core traits and functionality for embedded-graphics


Rust library for reading and writing PDF files


Simple image resampling library in pure Rust.

bvssvni kornelski Kagami github:pistondevelopers:publish


Safe wrapper for the Vulkan graphics API


gfx-rs hardware abstraction layer


The built-in widgets for iced


Cross-platform window context and rendering library.


Parse command line argument by defining a struct, derive crate.


Global override of color control


A terminal and console abstraction for Rust


A progress bar and cli reporting library for Rust


Zero-allocation terminal colors that'll make people go owo


Generate shell completion scripts for your clap::Command


Parse command line argument by defining a struct.


Test CLI Applications.


A command line prompting library.


An ultra simple CLI arguments parser.


inquire is a library for building interactive prompts on terminals


Number parsers for clap


Derive-based argument parsing optimized for code size

erickt benbrittain cramertj richkadel tmandry sadmac7000


Sqllogictest parser and runner.


A manpage generator for clap


A generator library used with clap for Nushell completion scripts


Application microframework with support for command-line option parsing,
configuration, error handling, logging, and terminal interactions.
This crate contains the framework's core functionality.

abscissa application cli framework service


Panic messages for humans

killercup yoshuawuyts epage spacekookie github:rust-cli:maintainers


Minimalist pedantic command line parser


Look up colored console capabilities


Snapshot testing toolbox


An argument parsing and validation library designed to take some of tediousness out of the general 'getopts' crate.


Utilities for search oriented command line applications.


Reduces boilerplate for adding a shell completion command to Clap


Load additional CLI args from file


Cross-platform terminal screen clearing


A simple Command Line Argument Parser with parser combinators


A crate for printing tables on command line


Reusable common Cargo command line options


Derive macros for bpaf Command Line Argument Parser


Control console coloring across all dependencies


A library which provides a set of methods to work with ANSI strings


Snapshot testing for a herd of CLI tests


Global override of color control


A common utility library to control CLI colorization


Display strings in a safe platform-appropriate way


A generator library used with clap for Fig completion scripts


Tracing layer that automatically creates and manages progress bars for active spans.

cli progress progress-bar progressbar tracing


Pretty-print tree-like structures


Extensible, asynchronous retry behaviours for futures/tokio


A proxy connector for Hyper-based applications


Future execution primitives


Async binding for Tungstenite, the Lightweight stream-based WebSocket implementation


A task scheduler backed by a work-stealing thread pool.


Asynchronous SOCKS proxy support for Rust.


Actor framework for Rust


Tokio support for signal-hook


Filesystem API for Tokio.


A convenience library for using websockets in WASM


Extensible, asynchronous retry behaviors for futures/tokio


Spawn scoped (non 'static) asynchronous futures for async_std and tokio runtimes


Compatibility adapter between tokio and futures


Internet Gateway Protocol client


Easily retry futures


Mix async code with CPU-heavy thread pools using Tokio + Rayon


Official Rust client for ClickHouse DB


Time utils from std::time, tokio::time and tokio_util::time on WASM targets


Retry your Futures and Streams!


A serial port implementation for tokio


Asynchronous pipe(2) library using tokio.


Bridging the protocol gap between Tokio and Tower

tower transport asynchronous protocol tokio


Schedule tasks on tokio using cron-like annotation, at an instant or repeat them at a fixed duration. Tasks can optionally be persisted using PostgreSQL or Nats.


An asynchronous ZIP archive reading/writing crate.


Some helper functions for tokio::io.


async MPSC request-response channel for Tokio


Pure-Rust LDAP Client


unix seqpacket sockets for tokio


Asynchronous ICMP ping library


Byte counting for std::io::{Read, Write, Seek} and
its async variants from futures and tokio.


Tokio-based file reader implementation for reqsign


An async/.await SOCKS5 implementation


[deprecated] A WebSocket (RFC6455) library for Rust.

rfc6455 tokio websockets websocket async

cyderize illegalprime github:rust-bus:maintainers github:websockets-rs:devs


Automatically deleted async I/O temporary files.


Asynchronous allocation of TUN/TAP devices using tokio


An implementation of AMQP1.0 protocol based on serde and tokio


Provides utilities for collecting Prometheus-compatible metrics from Tokio runtime and tasks.


Provide AsyncRead/AsyncWrite over Tungstenite WebSockets


Scoped Runtime for tokio


Asynchronous ICMP pinging library


Asynchronous wrapper around quiche


Tokio-based command execution implementation for reqsign


A WebSocket (RFC6455) library for Rust: low-level component. It contains HTTP-independent aspect of WebSockets

async rfc6455 websockets tokio websocket


macro to enable async drop in a tokio multithreaded runtime


An utility library to configure the tokio runtime via environmental variables


A convenience library for using websockets both in native and WASM environments!


IDNA (Internationalizing Domain Names in Applications) and Punycode.


HTTP date parsing and formatting


Default TLS implementation for use with hyper


typed HTTP headers core trait


Language tags for Rust


ureq support crate


HTTP mocking to test Rust applications.


Low level HTTP server library


Hyper bindings for Unix domain sockets


Common types for HTTP operations.


serve the web at warp speeds


Retry middleware for reqwest.

eopb skos-ninja tl-rodrigo-gryzinski tl-alessandro-caprarelli github:truelayer:rust-oss


High level server designed to be used with axum framework.


Small and lightweight HTTP client


Opentracing middleware for reqwest.

http middleware opentelemetry reqwest tracing

eopb skos-ninja tl-rodrigo-gryzinski tl-flavio-barinas github:truelayer:rust-oss


A backend-agnostic extension for HTTP libraries that provides support for POST multipart/form-data requests on both client and server.


HTTP mocking library for Rust


Serde support for the http crate. (De)serialize HeaderMap, Uri, Method, StatusCode


JSON-RPC v2 specific types


JSON-RPC client/server framework


Utilities for jsonrpsee


Hyper client bindings for Windows Named Pipes


HTTP requests library for WASM Apps


JSON-RPC client transports


JSON-RPC websocket client


Procedueral macros for jsonrpsee


RFC 6902, JavaScript Object Notation (JSON) Patch


The library provides the basic functionality to find the set of the data according to the filtering query.

json json-path jsonpath jsonpath-rust xpath


A protobuf library extending prost with reflection support and dynamic messages.


Generates Serialize and Deserialize implementations for prost message types


Utilities for pbjson conversion


Protobuf well known types with serde serialization support


A configuration library so con-free, it's unreal.


JSON schema to rust type code generator


RFC8259-compliant string escaping and un-escaping


JSON Schema validator and JSON coercer


JSON building DSL and configurable serializers for Rust


Fast Iterable JSON parser


Transport agnostic rust implementation of JSON-RPC 2.0 Specification.


Full Ethereum JSON-ABI implementation


Tiny simple JSON parser/generator


JSON-RPC HTTP client


JSON-RPC server that supports HTTP and WebSocket transports


It is JsonPath engine written in Rust. it provide a similar API interface in Webassembly and Javascript too. - Webassembly Demo: https://freestrings.github.io/jsonpath


A derive macro for prost-reflect to generate ReflectMessage implementations


A utility function for use with prost-build and prost-reflect to generate ReflectMessage implementations


Read and write GeoJSON vector geographic data

frewsxcv urschrei groteworld github:georust:geojson-publishers


JSON-RPC WASM client


Hjson serialization file format


serde_json for Wasm programs (small, deterministic, no floats)


serde_json Formatter to serialize as OLPC-style canonical JSON


Server utils for jsonrpc-core crate.


Publish-Subscribe extension for jsonrpc.


Rust http server using JSONRPC 2.0.


Transport agnostic JSON-RPC 2.0 client implementation.


A library to work with Javascript Object Signing and Encryption(JOSE),
including JSON Web Tokens (JWT), JSON Web Signature (JWS) and JSON Web Encryption (JWE).


Simple, minimal-dependency HTTP client


Easy to use, secure, non opinionated JWT (JSON Web Tokens) implementation for Rust.


High-fidelity JSON lexer and parser


Sonic-rs is a fast Rust JSON library based on SIMD


DEPRECATED: Use Cargo environment variables `CARGO_CFG_TARGET_*`


Simple JSON parser. Wasm / no_std ready.


Rust support for the JSON-RPC 2.0 protocol

apoelstra sgeisler stevenroose tcharding


Serde-compatible spanned Value


Zero-copy vector backed by a byte array

memory-efficiency serde serialization zero-copy


Serde traits only, with no support for derive -- use the `serde` crate instead


Generate JSON Schemas from Rust code


YAML data format for Serde


Custom de/serialization functions for Rust's serde

deserialization serde serialization utilities


proc-macro library for serde_with


Derive Serialize and Deserialize that delegates to the underlying repr of a C-like enum.


Path to the element that failed to deserialize


serde implementation of CBOR using ciborium-basic


Type-erased Serialize and Serializer traits


AST representation used by Serde derive macros. Unstable.


Optimized handling of `&[u8]` and `Vec<u8>` for Serde


Macros for #[derive(JsonSchema)], for use with schemars


Serialization value trees


Serde support for MessagePack


CBOR support for serde.


Native Serde adapter for wasm-bindgen

webassembly wasm serde serialization javascript


Serde support for the `humantime` crate


Serde `Visitor` implementation for deserializing untagged enums


Minimal TOML library with few dependencies


`Cargo.toml` struct definitions for parsing with Serde


A no_std + serde compatible message library for Rust


Find out about keys that are ignored when deserializing data


A serde wrapper that (de)serializes regex as string


Serde serializable and deserializable trait objects


Constant-time serde serializer/deserializer helpers for data that potentially
contains secrets (e.g. cryptographic keys)


Token De/Serializer for testing De/Serialize implementations

dev-dependencies serde serialization testing


A serde deserializer for proc_macro::TokenStreams


A restricted plain text serializer for serde


Type that deserializes only from one specific value


A serde crate's auxiliary library


Encoding and decoding support for BSON in Rust

bson deserialization mongodb serde serialization


DEPRECATED — `serde_yml` is unmaintained. This release is a thin compatibility shim that forwards every call to `noyalib` (a pure-Rust, `#![forbid(unsafe_code)]` YAML library). Please migrate to `noyalib`.


DEPRECATED — `libyml` is unmaintained. This release is a thin compatibility shim that forwards every call to `unsafe-libyaml` (the upstream C-libyaml translation `libyml` was originally forked from). Please migrate to `unsafe-libyaml`, `yaml-rust2`, or `noyalib`.


deserialize env vars into typesafe structs


Conditional compilation according to rustc compiler version


Helpful macros for working with enums and strings


A library for reading and writing the DWARF debugging format.


Replacement for crate (macro_rules keyword) in proc-macros


Macros for all your token pasting needs


Compile-time assertions to ensure that invariants are met.


A minimal `syn` syntax tree pretty-printer


Adds #[derive(x)] macros for more traits


A tiny utility to help save you a lot of effort with long winded `#[cfg()]` checks.


Automatically generates Rust FFI bindings to C and C++ libraries.


Find windows-specific tools, read MSVC versions from the registry and from COM interfaces


Almost drop-in replacement to panics in proc-macros


A build dependency for running `cmake` to build a native library


Statistics-driven micro-benchmarking library

berkus bheisler lemmih github:rust-bus:maintainers


Object-safe value inspection, used to pass un-typed structured data across trait-object boundaries.


UTF-8 paths


Build configuration for the PyO3 ecosystem