Bindings to Python interpreter


Proc macros for PyO3 package


Code generation for PyO3 package


Python-API bindings for the PyO3 ecosystem


Lossless functionality for platform-native strings


Overwrite `assert_eq!` and `assert_ne!` with drop-in replacements, adding colorful diffs.


Rust macro to automatically implement the builder pattern for arbitrary structs.


Global, no_std-compatible constructors for all platforms that run before main (like C/C++ __attribute__((constructor)))


Hypothesis-like property-based testing and shrinking.

fuzz hypothesis property quickcheck testing


Procedural macros in expression position


Import lib for Windows


Cross-platform interface to the `errno` variable.


Rust friendly bindings to *nix APIs


get the IANA time zone for the current system


Hermit system calls definitions.


Raw FFI bindings for all of Windows API.


A Rust equivalent of Unix command "which". Locate installed executable in cross platforms.


Bindings to Core Foundation for macOS

larsbergstrom metajack mbrubeck pcwalton github:servo:cargo-publish


Core type support for COM and Windows


A dumping ground for high level safe wrappers over windows-sys.


Linking for Windows


Windows error handling


Rust for Windows


Windows string types


UEFI Reference Specification Protocol Constants and Definitions


iana-time-zone support crate for Haiku OS


The implement macro for the Windows crates


The interface macro for the Windows crates


A minimal library that determines the number of running threads for the current process.


Rust bindings to MS Windows Registry API


A crate to wait on a child process with a timeout specified across Unix and
Windows platforms.


Cross-platform system's host name functions


Rust library for getting information about the current user and environment


A low-level I/O ownership and borrowing library


Bindings to SystemConfiguration framework for macOS


Low level bindings to SystemConfiguration framework for macOS


Wrapper types and traits for secret management which help ensure
they aren't accidentally copied, logged, or otherwise exposed
(as much as possible), and also ensure secrets are securely wiped
from memory when dropped.


A thread pool for running a number of jobs on a fixed set of worker threads.

pool parallelism threading thread threadpool

huonw frewsxcv github:servo:cargo-publish github:rust-threadpool:publishers


Easy Ctrl-C handler for Rust projects


Async interface for working with processes


Type-safe, compiled Jinja-like templates for Rust

GuillaumeGomez djc Kijewski github:askama-rs:maintainer


A template engine for Rust based on Jinja2/Django


Parser for Askama templates


a powerful template engine for Rust with minimal dependencies


runtime format strings, fully compatible with std's macros


shell-like variable substitution

expansion parameter shell substitution variable


The liquid templating language for Rust


The liquid templating language for Rust

html language liquid template templating


Core liquid functionality


Markdown Renderer for the Terminal


Compile-time HTML templates.


A whitespace-aware quasiquoter for beautiful code generation.


Library for basic server-side rendering written in pure rust


Simple Customizable String-Templating Library for Rust.


Templating for the Fluent localization framework

fluent handlebars internationalization localization tera


Clone of C s(n)printf in Rust


A macro for formatting non literal strings at runtime


The Golang Templating Language for Rust


Small wrapper for typst that makes it easier to use it as a templating engine


Simple, small, and extremely fast template engine for Rust


A simple, powerful template engine with minimal dependencies and configurable delimiters

handlebars jinja2 liquid mustache template


a templating library written in rust macros


A compatibility add-on for Askama to support many different web frameworks


You can read and write data using XML and output various structured documents.You can also program using javascript/TypeScript.It's Deno compatible.And you can optionally use python.


A blazing fast, type-safe template engine for Rust.


Layers, extractors and template engine wrappers for axum based Web MVC applications


A simple macro for generating Rust codes


Very simple string template for Rust.


Experimental Mustache-like templating engine.


This crate has moved to `tpnote`


Helps parsing and evaluating binary expression trees


Rust Compiled Templates, efficient type-safe web page templates.


Helper collection for yarte


Procedural macro package for yarte


Type-safe, compiled Handlebars


Minimal compile-time Rust template engine


Intermediate representation for yarte


Code generator for yarte


Ast, lexer and parser for yarte


A collection of helpers for handlebars (rust) to manage string, json, yaml, toml, path, file, http request.


The liquid templating language for Rust

templating language template liquid html


The liquid templating language for Rust


Beautiful diagnostic reporting for text-based programming languages


Link libstdc++ or libc++ automatically or manually


Compiler configuration of the `cxx` crate (implementation detail)


Pure Rust implementation of Gherkin language (`.feature` file) for Cucumber testing framework.

bdd cucumber cucumber-gherkin gherkin testing


Cucumber Expressions AST and parser.

cucumber cucumber-expressions expression expressions


A rust implementation of the protobuf compiler.


Parsing of protobuf source files


Data structures for tracking locations in source code

diagnostics serialization source-location structures tracking


CommonMark compliant markdown parser in Rust with ASTs and extensions

commonmark markdown parse render tokenize


Core implementation of the Cedar policy language

cdisselkoen aaronjeline john-h-kastner-aws katherine-hough lianah victornicolet github:cedar-policy:core-cedar-devs


Vector Remap Language

datadog dsl observability processing vector


Project root for all TypeSpec-related crates.


Client runtime for TypeSpec-generated libraries.


Cedar is a language for defining permissions as policies, which describe who should have access to what.


Procedural macros for client libraries built on typespec.


Policy formatter for the Cedar Policy Language.


A collection of JavaScript tools written in Rust.

javascript linter minifier parser typescript


An OpenAPI client generator


Common runtime utilities used by diplomat codegen


Shared utilities between Diplomat macros and code generation


The diplomat FFI generation macro


Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.


Abstract Syntax Tree definition for the Boa JavaScript engine.


ECMAScript parser for the Boa JavaScript engine.


Validator for the Cedar Policy language.


Interpreter for the jaq language


Parser and syntax tree for Typst.


Performance timing for Typst.


Utilities for Typst.


Assets for the Typst compiler.


A new markup-based typesetting system that is powerful and easy to learn.


Proc-macros for Typst.


SVG exporter for Typst.


Implementation agnostic memory allocator for Vulkan like APIs


Core types of gpu-alloc crate


Cross-platform software buffer


Bindings for using egui with winit


Bindings for using egui natively using the glow library


egui framework - write GUI apps that compiles to web and/or natively


Extra functionality and widgets for the egui GUI library


Bindings for using egui natively using the wgpu library


Load/save functionality for 3d applications.


3 dimensional collision detection library in Rust. 64-bits precision version.


Docking system for egui - an immediate-mode GUI library for Rust


Parser for the ktx2 texture container format


3-dimensional physics engine in Rust.

dynamics impulse_joints physics real-time rigid


Composable camera rigs


3 dimensional collision detection library in Rust.


2 dimensional collision detection library in Rust.


3-dimensional physics engine in Rust.


Inspector plugin for the bevy game engine


Interop library between ash and raw-window-handle

raw-window-handle windowing graphics ash vulkan


2-dimensional physics engine in Rust.


Expressive audio library for games


2 dimensional collision detection library in Rust. 64-bit precision version.


DirectDraw Surface file format parser/composer


Bevy plugin for asset loading


Macro implementation for bevy_asset_loader


`ash` backend for `gpu-alloc`


Backend-agnostic interface for writing apps using egui


Parser for the Collada (DAE) format


Bevy plugin for dynamic audio


A powerful, flexible and ergonomic way to manage action-input keybindings for the Bevy game engine.


Bindings for the basis-universal Supercompressed GPU Texture Codec by Binomial

gpu basis-universal texture compression game


Bindings for using egui natively using the glium library


Show puffin profiler flamegraph in-game using egui


Extensions for glam: Pose2, Pose3, Rot2, and matrix utilities.


Transform interpolation for fixed timesteps for the Bevy game engine


Mass property computation for Bevy's geometric primitives.


A basic pan and orbit camera in Bevy


An ECS-driven physics engine for the Bevy game engine


Bevy plugin adding support for loading your own asset types from common file formats such as json and yaml


A rust crate for loading maps created by the Tiled editor


A Bevy plugin to embed assets in your game


Matrix types and utilities for Glam.


Polyline Rendering for Bevy


Low level Rust bindings for SDL 3

gamedev graphics multimedia sdl windowing


A NNUE-based chess engine that implements the Negamax algorithm and can be integrated into any project as a library. It features move generation, advanced position evaluation through NNUE, and move searching capabilities.


Provides types and useful methods for working with IPv4 and IPv6 network addresses, commonly called IP prefixes. The new `IpNet`, `Ipv4Net`, and `Ipv6Net` types build on the existing `IpAddr`, `Ipv4Addr`, and `Ipv6Addr` types already provided in Rust's standard library and align to their design to stay consistent. The module also provides useful traits that extend `Ipv4Addr` and `Ipv6Addr` with methods for `Add`, `Sub`, `BitAnd`, and `BitOr` operations. The module only uses stable feature so it is guaranteed to compile using the stable toolchain.


A high performance, zero-copy URL router.


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

binary decode deserialize encode serialize


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


Binary Object Representation Serializer for Hashing


Retry operations with exponential backoff policy.


A library to work with IP CIDRs in Rust


Tokio-based single-threaded async runtime for the Actix ecosystem


Codec utilities for working with framed protocols


Various utilities used in the Actix ecosystem


Service trait and combinators for representing asynchronous request/response operations.


A library to generate and parse UUIDs.


Split a string into shell words, like Python's shlex.


libyaml transpiled to rust by c2rust


Library to support the reading and writing of zip files.


Parse and inspect Rust literals (i.e. tokens in the Rust programming language
representing fixed values). Particularly useful for proc macros, but can also
be used outside of a proc-macro context.

literal parsing proc-macro procedural type


SIMD-accelerated base64 encoding and decoding


The resolv.conf file parser


A high-level, safe, zero-allocation font parser for TrueType, OpenType, and AAT.


A library to encode and decode LEB128 compressed integers.


A parser and evaluator for Rust `cfg()` expressions.


Rust library to easily compare version numbers with no specific format, and test against various comparison operators.


Kube shared types, traits and client-less behavior


Numeric traits for generic mathematics


Integer traits and functions


Big integer implementation for Rust


Wrappers for total ordering on floats


Rational numbers implementation for Rust


Complex numbers implementation for Rust


External iterators for generic mathematics


A collection of numeric types and traits for Rust, including bigint,
complex, rational, range iterators, generic integers, and more!


Numeric syntax extensions


Decimal number implementation written in pure Rust suitable for financial and fixed-precision calculations.

decimal financial fixed number precision


General matrix multiplication for f32 and f64 matrices. Operates on matrices with general layout (they can use arbitrary row and column stride). Detects and uses SIMD features on x86/x86-64 and AArch64 transparently for higher performance. Uses a microkernel strategy, so that the implementation is easy to parallelize and optimize.

Supports multithreading.


An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.

array blas data-structure matrix multidimensional


Arbitrary precision decimal numbers

arbitrary-precision bignum decimal numerics


Functions for finding row-minima in a totally monotone matrix.

dynamic-programming matrix optimization smawk


Geometry primitives

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


PyO3-based Rust bindings of the NumPy C-API

termoshtt davidhewitt kngwyu github:rust-numpy:publish github:pyo3:rust-numpy


An R*-tree spatial index

nearest-neighbor r-tree rtree spatial spatial-index

urschrei Stoeoef michaelkirk github:georust:rstar-publishers


High-performance FFT library written in pure Rust.


Robust adaptive floating-point predicates for computational geometry


Geospatial primitives and algorithms


Shorthand macros to assist creating Decimal types.


A safe Rust wrapper for ONNX Runtime 1.28 - Optimize and accelerate machine learning inference & training


Unsafe Rust bindings for ONNX Runtime 1.28 - Optimize and Accelerate Machine Learning Inferencing


Real-to-complex forward FFT and complex-to-real inverse FFT for Rust


ArgMinMax (argmin & argmax in 1 function) with SIMD for floats and integers


Units of measurement

dimensional-analysis measurement no_std si units


.npy and .npz file format support for ndarray


Dynamic generic 2D data structure.


Low-level manipulations of IEEE754 floating-point numbers.

float no_std floating-point mathematics numerics


A library for reading and writing MCAP files


Calculate statistics iteratively


Cross platform serial ports


Minimalist ML framework.


Safe and minimal CUDA bindings


Boolean Operations for 2D Polygons: Supports intersection, union, difference, xor, and self-intersections for all polygon varieties.


Statistical routines for the n-dimensional array data structures provided by ndarray.

array matrix multidimensional ndarray statistics


Rust wrappers for the PyTorch C++ api (libtorch).


Low-level FFI bindings for the PyTorch C++ api (libtorch).

deep-learning ffi machine-learning pytorch


Compute Discrete Cosine Transforms (DCT) of any size in O(nlogn) time, in pure Rust.


8-bit floating point types for Rust


Generate DIMACS CNF formula from operations


A Rust Library for basic parsing and handling of logical formulas(forked from coastalwhite)


Generic and optimized primality test, factorization and various number theoretic functions with arbitrary precision based on `num`.

bigint mathematics num number-theory primes


Micro compiler for tensor operations.


WASI API bindings for Rust


Easy support for interacting between JS and Rust.


Bindings for all JS global objects and functions in all JS environments like
Node.js and browsers, built on `#[wasm_bindgen]` using the `wasm-bindgen` crate.


Drop-in replacement for std::time for Wasm in browsers


A Rust drawing library focus on data plotting for both WASM and native applications

drawing plotting visualization webassembly


WASIp2 API bindings for Rust


Convenience crate for working with JavaScript timers


WASIp3 API bindings for Rust


WASI Terminal Environment API


A panic hook for `wasm32-unknown-unknown` that logs panics to `console.error`


Convenience crate for common `web_sys` features


Standalone environment support for WebAssembly code in Cranelift


Typed GraphQL requests and responses


Private implementation details of the uuid! macro.


WebAssembly interpreter


Core primitives for the wasmi WebAssembly interpreter


Integration between Cranelift and Wasmtime


WebAssembly low-level format library

serde interpreter wasm webassembly bytecode


Translator from WebAssembly to Cranelift IR


A small, self-contained, wasm-friendly Ed25519 implementation


Runtime library support for Wasmtime


A collection of Array/Bytes/Hex utilities with full No-STD compatibility.


Internal macros used by the `walrus` crate, not for public consumption.


JIT-style execution for WebAsssembly code in Cranelift


A library for performing WebAssembly transformations


Parse and validate witx file format


generate typescript bindings from rust types


INTERNAL: Integration between Cranelift and Wasmtime


Specialized data structures for the Wasmi interpreter


Wiggle code generator


Library crate for wiggle code generator.


Runtime components of wiggle code generator


Embedded scripting for Rust

embedded scripting scripting-engine scripting-language


WASI implementation in Rust


Command line interface of the `#[wasm_bindgen]` attribute and project. For more
information see https://github.com/wasm-bindgen/wasm-bindgen.


Procedural macros support package for Rhai, a scripting language and engine for Rust

embedded plugin scripting scripting-engine scripting-language


Instrument and transform wasm modules.

parity wasm gas-metering blockchain webassembly


Tsify is a library for generating TypeScript definitions from rust code.


Bindings to the C api for FoundationDB


High level client bindings for FoundationDB.


Binding generation helper for FoundationDB.


DataFusion tracing of execution plans

analytics datafusion instrumentation query-execution tracing


Object Store instrumentation through tracing

cloud instrumentation object-store storage tracing


tendermint-proto is a the Rust implementation of the Tendermint proto structs.


Foundationdb tuple pack/unpack implementation in rust


Mysql client library implemented in rust


Tendermint is a high-performance blockchain consensus engine that powers
    Byzantine fault tolerant applications written in any programming language.
    This crate provides core types for representing information about Tendermint
    blockchain networks, including chain information types, secret connections,
    and remote procedure calls (JSON-RPC).

bft blockchain consensus cosmos tendermint


Rust task runner and build tool.


Manage cargo cache ($CARGO_HOME or ~/.cargo/), show sizes and remove directories selectively


Proxy for LLVM tools like llvm-nm, llvm-objdump and llvm-size


Rust tool to collect and aggregate code coverage data for multiple source files


Proc Macro attributes for the Paw crate.


CLI argument parser.


Make your terminal output colorful


Traits to implement custom Paw implementations


The duckscript SDK.


Coverts simple basic shell scripts to windows batch scripts.


Simple, extendable and embeddable scripting language.


A CLI for Taplo TOML toolkit


Make Debian packages (.deb) easily with a Cargo subcommand


Semantic conventions for OpenTelemetry


Rust bindings to libcurl for making HTTP requests


A websocket protocol implementation.