Lib.rs

libm

libm in pure Rust

cxx

Safe interop between Rust and C++

errno

Cross-platform interface to the errno variable

const_panic

const panic with formatting

target-lexicon

LLVM target triple types

hash32

32-bit hashing algorithms

colorous

Professional color schemes ported from d3-scale-chromatic

petname

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

assert_matches

Asserts that a value matches a pattern

average

Calculate statistics iteratively

askama_escape

HTML escaping, extracted from Askama

spectrum-analyzer

An easy to use and fast no_std library (with alloc) to get the frequency spectrum of a digital signal (e.g. audio) using FFT.

opaque-ke

OPAQUE password-authenticated key exchange protocol

ptr_meta

A radioactive stabilization of the ptr_meta rfc

str-buf

Static string buffer

nc

Access system calls directly

msvc-demangler

that demangles / undecorates C++ symbols mangled by MSVC

unicode-properties

Query character Unicode properties according to UAX #44 and UTR #51

coolor

conversion between color formats

origin

Program startup and thread support written in Rust

obfstr

Compiletime string constant obfuscation for Rust

no-std-compat

A #![no_std] compatibility layer that will make porting your crate to no_std easy

gsw

TEOS-10 v3.06.12 Gibbs Seawater Oceanographic Toolbox in Rust

tstr

Type-level strings

core_extensions

Extensions for core/std library types, and other miscelaneous features

blobby

Iterator over simple binary blob storage

typeid

Const TypeId and non-'static TypeId

impl-more

Concise, declarative trait implementation macros

coap-message

Interface to CoAP messages

daft

Structural diffs of Rust data structures

cranelift-entity

Data structures using entity references as mapping keys

ezlua

Ergonomic, efficient and Zero-cost rust bindings to Lua5.4

font8x8

8x8 monochrome bitmap font for rendering

hermit-entry

Hermit's loading and entry API

figlet-rs

FIGlet to create ascii art

core2

The bare essentials of std::io for use in no_std. Alloc support is optional.

serial_int

Safe, easy-to-use auto-increment integers

material-colors

Up-to-date material-color-utilities port

raw-parts

Ergonomic wrapper around Vec::from_raw_parts and Vec::into_raw_parts

wyz

myrrlyn’s utility collection

trimothy

Traits for trimming slices, vecs, and strings

build-context

Make build environment/target information available as constants in normal libraries and binaries

trackball

Virtual Trackball Orbiting via the Exponential Map

panic-halt

Set panicking behavior to halt

unarm

Disassembles ARM instructions

bitmask-enum

A bitmask enum attribute macro

febug

anyway, here's user-space debugfs

limine

parsing the limine boot protocol structures

matte

Minimalist and allocation free GUI Layout

lite-json

JSON parser. Wasm / no_std ready.

constgebra

Const Linear Algebra

js_int

JavaScript-interoperable integer types

earcut

port of the Earcut polygon triangulation library

json-rpc-types

Type definitions for JSON-RPC

no_std_io2

The bare essentials of std::io for use in no_std. Alloc support is optional.

bitflag

A macro to generate bitflags structures from C-like enums

tiny-std

Tiny rust stdlib for linux

const-default

A const Default trait

hostname-validator

Validate hostnames according to IETF RFC 1123

handler_table

A lock-free table of event handlers

cranelift-module

Support for linking functions and data with Cranelift

peekmore

Iterator adapter like Peekable, but for peeking forward multiple elements

opencl-sys

OpenCL C FFI bindings for the Rust programming language

sdl3-src

Source code of the SDL 3 library

efd

1D/2D/3D Elliptical Fourier Descriptor (EFD) implementation in Rust

wary

validation and transformation library

bitfrob

A sibling crate for bytemuck, this is where forbid(unsafe_code) utilities live

generativity

Generation of unique invariant lifetimes

x2apic

interface to the x2apic interrupt architecture

nostd

Missing std types for no_std development

ebds

Messages and related types for implementing the EBDS serial communication protocol

amplify_apfloat

rustc_apfloat with u256 backend to utilize Octuple precision floating-point format

typesize

fetch an accurate estimate of the total memory usage of a value

bit-struct

Define structs which have fields which are assigned to individual bits, not bytes

cwenum

A tiny crate to access a strongly typed common weakness enumeration (cwe) object

indexed-merkle-tree

Indexed Merkle Trees, a version of Merkle trees that supports both membership and non-membership proofs

array-util

no_std array helpers available without nightly

inc_dec

Incrementation and decrementation in Rust

no_std_io

The bare essentials of std::io for use in no_std. Alloc support is optional.

as-slice

AsSlice and AsMutSlice traits

one-shot-mutex

One-shot locks that panic instead of (dead)locking on contention

c-scape

A libc bottom-half implementation in Rust

odds

ends — collection miscellania. Extra functionality for slices (.find(), RevSlice), strings and other things. Things in odds may move to more appropriate crates if we find them.

trim-in-place

In-place trimming strings

soundchip

Software sinth with configurable channels for authentic sounding virtual sound chips

assign

macro to allow mutating instance with declarative flavor

ty-tag

TypeId for lifetime containing types via type tags

etag

calculation implementation

interlock

Readers-writer locks designed for locking intervals

kernel-elf-parser

An lightweight ELF parser that parses ELF files and converts them into information needed for kernel building

arm-attr

Reads ARM build attributes of an ELF file

erased-discriminant

Type-erased version of core::mem::Discriminant<T>

sew

Weird strings

mser

copy_from_str

An extension trait to copy a string into another string

encrust

Obfuscate data in memory to hide it until needed

fbd_sequencer

A sequencer for playing music using PSG or AY-3-8910 sound sources. Supports playing .fbd sequence files.

package-family-name

calculating MSIX Package Family Name values

cpf

Brazilian CPF parsing, validating and formatting library

auto-delegate

Auto delegate allows you that automatic impl of traits and delegate their handling to child members

ser-write

Common traits for writer-style serializers and deserializers designed for no_std targets

branches

Branch hinting prediction and control functions for stable Rust including likely, unlikely, assume and abort to help algorithm optimization

as_variant

macro to convert enums with newtype variants to Options

x86-simd

Safe interfaces to x86 and x86_64 SIMD intrinsics

cwextab

CodeWarrior Exception Table decoder

icao-units

Units for air navigation as defined in ICAO Annex 5

pkmn-savedata

Reads and modifies save data for Pokémon games

kanata-keyberon

Pure Rust keyboard firmware. Fork intended for use with kanata.

errno-no-std

Cross-platform interface to the errno variable

axio

std::io-like I/O traits for no_std environment

repr_offset

Offsets of fields for types with a stable layout

c-enum

A macro to generate c-like enums

itermaps

Implement commonly used combinations of Iterator::map

generic-array-storage

nalgebra storage implementation backed by generic_array

sysml-model

SysML.rs

coap-message-implementations

Implementations of coap-message traits, and tools for building them

header-vec

Vector with user-specified header, length, capacity, and array elements all stored on the heap together

nowasm

No-std, no-unsafe and no-dependencies WebAssembly 1.0 runtime library

riot-wrappers

Rust API wrappers for the RIOT operating system

rawbytes

View/access any sized value as a &[u8]

with_drop

Nostd wrapper for using a closure as a custom drop function

currency-iso4217

ISO 4217 currency codes

stary

A collection of modules that aim to feel like extensions of core, alloc, and std

softfloat

Pure software floating-point implementation, with const and no_std support

unix_path

Unix-compatible paths regardless of platform

aula01

Biblioteca de funções

drawbridge-byte

working with contiguous arrays of bytes and easy conversions to and from Base64 representations in string contexts

digit-layout

unified data type definition across various libraries, efficiently encodes types in a compact layout, thus avoiding the redundancy of enumerating definitions for data types

tagptr

Strongly typed atomic and non-atomic tagged pointers

page-table-generic

general page table operations

selfie

Experimental, macro-free and allocation-free self-referential structs

sub-strs

serde_derive

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

simd-abstraction

Abstract SIMD instruction sets

no-panic

Attribute macro to require that the compiler prove a function can't ever panic

array-section

An array where only a (contiguous) subarray may be viewed or operated on

virtio-spec

Definitions from the Virtual I/O Device (VIRTIO) specification

utf8-parser

A one-byte-at-a-time UTF-8 parser

core-error

std::error::Error for libcore

omeganum

Stores numbers up to 10{N}9e15

atools

const generic expr based fixed length array manipulation

vga

Support for vga specific functions, data structures, and registers

gstr

An immutable string implementation optimized for small strings and comparison

bit_reverse

Computes the bit reversal of primitive integers

atomic-int

Atomics for additional integers, like C/FFI types

simple-blit

blitting from one surface to another with some possible transformations

mini-loader

capable of loading and executing ELF files, including Executable file and Position-Independent Executable file

lock_ordering

Lock ordering enforcement at compile time

can-types

encoding/decoding simple CAN bus data structures

ser-write-json

JSON serializer for ser-write and deserializer for convenience

nvtx

Rust bindings for the NVIDIA® Tools Extension SDK (NVTX)

ssp

Messages and related types for implementing the SSP/eSSP serial communication protocol

rand_core_compat

A compatibility layer for different versions of rand_core

pid-allocator

PID allocator for no_std environment

department

proposed Storages API

nairud

always_send

Wrapper to check Send only on construction, so rustc isn’t confused later

padstate

Tiny structs that hold a game controller's state

fielder

Efficient and precise bitfields

micrortu_sdk

SDK for MicroRTU

tuple_len

Get the number of elements in a tuple

bitarray

A const generics driven bit array specialized for hamming distance

yotta

A no_std arbitrary-precision arithmetic library

bitflags-serde-legacy

Implement serde traits for bitflags 2.x types compatibly with 1.x

short-names

Add very short names to some methods in the core

xsens-mti

An unofficial and incomplete no_std Rust driver for Xsens MTi-series sensors

display-interface-spi

Generic SPI implementation for display interfaces

reclone

creating a new scope with a set of cloned variables

mc-sgx-util

shared by SGX libraries

wasefire-one-of

Macros for mutually exclusive features

smooth-buffer

ring buffer that can average values without iterating

const-generic-alignment

Const-generic-aligned ZST

cstr_core

CStr and CString for no_std environments

cranelift

Umbrella for commonly-used cranelift crates

dyspxkrypt-libuefi

Raw bindings of UEFI that conforms to the definitions of the UEFI Specification

bind-hal

MCU HALs using binding, currently supports PY32

nostd_cow

A no_std implementation of std::borrow::Cow

acolor

Color representations, operations and conversions

sallyport

API for the Enarx hypervisor-microkernel boundary

predicator

allows the creation, loading, and unloading of Rust and other language plugins on the fly using LLVM's ORC JIT

cbitset

A bit set, being able to hold a fixed amount of booleans in an array of integers

no-std-compat2

A #![no_std] compatibility layer that will make porting your crate to no_std easy. This fork fixes build upto Rust Edition 2021

line-column

calculate lines and columns of str index

manyzip

Zip an arbitrary number of iterables

default-option-arr

Macros for simple default initialization of arrays of option types

rel-ptr

building movable self-referential types

useful_number

that provides useful number types

flags

A macro to generate structures which behave like bitflags

konst_kernel

Foundational const functionality shared between konst and const_panic

igvm_defs

specification for the Independent Guest Virtual Machine (IGVM) file format

woke

A minimalistic waker implementation for executors

hashing-serializer

Serialize serde-implementing structures directly into a hash

rlwinmdec

PPC Rlwinm/Rlwnm/Rlwimi Decoder Tool

scanmut

Insert/remove multiple items from Vecs in O(n) time

origin-studio

An alternative std-like implementation built on origin

kerml

SysML.rs

const-bitfield

Macros for generating bitfield-like structures with const support

figleter

FIGlet to create ascii art. With kerning.

b2histogram

A compact and efficient integer histogram with fixed memory footprint, constant runtime performance, and (WIP) compact binary serialization

ac-power

Reference frames and transforms for ac power analysis

card10-l0dable

make l0dables for the Card10 (CCCamp 2019) badge

cbitmap

A conventional, compact and core (no_std) bitmap

uwasm

Runtime for WebAssembly modules, suitable for use as a loader for user apps in firmwares running on microcontrollers like ESP32

array-tools

A little collection of array-related utils aiming to make life easier

number-as

Extend primitive number types to make them have a number_as method

acid_io

A pared-down version of std::io usable with no_std

staged-builder

A proc macro which generates staged builders for types

os-timer

OS Timers for Rust

dtb-walker

package for DTB depth-first walking

static-slicing

enhanced slicing and indexing

coap-numbers

Constants for the CoAP protocol

serde_keyed_derive

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

wmm

WMM no_std library used to calculate the magnetic declination

multiboot2-common

Common helpers for the multiboot2 and multiboot2-header crates

coordinate-frame

Very simple coordinate frame conversions

copic_colors

Copic color list

x86-alignment-check

x86 aligment check flag manipulation

neorv32

High-level bindings for NEORV32 HAL and library

checks

Adds several compile time checks for const generics

eint

Fixed-size signed/unsigned big integers

nethost-sys

FFI bindings for nethost

wizdraw

Tiny no_std crate to fill and stroke composite bezier curves (SIMD/SSAA)

sdl3-image-src

Source code of the SDL3_image library

alloc-compose

Composable allocator structures for plugging together more powerful allocators

sqsh-sys

Low-level bindings to the libsqsh library

sdl3-image-sys

Low level Rust bindings for SDL3_image

encap_enum

A non-verbose way to define a group of constants and bit flags

str-concat

Concatenate two adjacent string slices

kvs

Embedded Key-Value Store

allocator-fallback

Minimal fallback for the standard library’s allocator API

spacesuit

Embedded license information

unsafe_unwrap

Unsafely unwrap Result and Option types without checking

bearingpro

solving common maritime navigation tasks

elf_parser_rs

An lightweight ELF parser that parses ELF files and converts them into information needed for kernel building

nanval

A no_std, zero-dependency crate for the creation and handling of NaN-tagged 64-bit floating-point values

ser-write-msgpack

MessagePack serializer for ser-write and deserializer for convenience

cranelift-bforest

A forest of B+-trees

bytecursor

No-std replacement for std::io::Read, std::io::Write, and std::io::Seek

p384

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.

rand_blake3

rand implementations for blake3 types

primeorder

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

compat-no-std

A #![no_std] compatibility layer that will make porting your crate to no_std easy

lowpass-filter

no_std Rust library for simple digital low pass filters. You can use it for example to get the low frequencies from a song.

dshot-frame

Generates frames for the DShot ESC protocol

page-table-arm

arm page table

panic-ext

Extension library to panic facilities to make it more usable

fleck

A uf2 font parser

pkmn-core-types

Basic types for Pokémon games

vga-figures

drawing various shapes

squfof

Shanks's square forms factorization

stivale-boot

parsing stivale and stivale 2 structures

exit-no-std

Cross-platform interface to the process exit function

primitive_promotion

Primitive promotions for primitive numeric types: u16 for u8, i32 for i16, f64 for f32, etc

drop-move

support moving out of drop

fisica

A physics library

cpio_reader

read the contents of cpio files

simple_on_shutdown

consists of a convenient macro to specify on shutdown callbacks (=code that should run when your program exits (grafecully)). It's super simple and stripped-down.

minicbor-adapters

Adapters between minicbor and other crates such as heapless and cboritem

lolid

Minimal UUID implementation

splitter

A string and slice splitter library

rsfuzzymind

fuzzy logic that includes fuzzy set operations, rule-based evaluations, and inference for determining priorities

tracing-serde-wire

Wire types for use with tracing-serde-structured crate

align-address

Functions for aligning addresses

chek

An assertions library

cop

Highly efficient first-order connection proving

camelpaste

A fork of paste using lowerCamelCase (hopefully temporary)

rusl

Rust linux interface layer

magic-sys

Declarations for the libmagic C library

display-interface

Traits for interfaces used to drive displays

hex-display

Display impl for byte slices which provides a hexdump

krnlstring

Safe Rust abstractions for handling Windows Unicode strings (UNICODE_STRING) in #![no_std] environments

kiam

Better syntax for if/else chains (when!)

intbits

Easy access to individual bits of integers

rcelebrone_functions

Apenas um teste no curso de rust

datafusion_imu

Performs datafusion for 6 or 9 DOF sensors

waterworks

A small library for chaining together computation stage into a pipeline

combinatory

Create every combination possible of values of 2D collections / iterators

self-reference

Helper

cargo-no-std-check

Check that a crate builds without std

align-data

Simply increase the alignment of any statics or include_bytes!

electricui-embedded

An unofficial and incomplete no_std Rust library for implementing the ElectricUI Binary Protocol

static-array

A no-std rust crate providing a heap-allocated non-resizable type-checked array

sipmsg

SIP message parser

allocandrescu

A collection of various allocators and allocator combinators

fixed-filters

fixed-point digital filters

if_rust_version

Macro to enable or disable code depending on the rust version

lite-parser

parser library. Wasm / no_std ready.

const-frac

Types for supporting floating point constants

bip32

hierarchical key derivation implemented in a generic, no_std-friendly manner. Supports deriving keys using the pure Rust k256 crate or the C library-backed secp256k1 crate

simdprune

Pruning elements in SIMD vectors (i.e., packing left/compressing elements)

err-into

Extension traits for core::convert::Into to use with Results and Options

saturating

Saturating<T>, an intentionally-saturating arithmetic wrapper

strict_result

Adds a Result::strict()? function to help with type inference

gat-std

Variants of Rust std traits that use GATs

is_wine

easily check if the current app is running under wine

r-linux

Capability-based Linux Runtime

rssafecircuit

implements a Circuit Breaker pattern with asynchronous support using Tokio, managing failure states and recovery strategies

valip

Parsing of ip addresses from bytes representing strings

sysml-parser

SysML.rs

arraytools

A variety of helpful methods for working with fixed-size arrays

abs_mm

Abstract Memory Management

pink-json

serde-json for pink programs

tinysyscall

a (no depend std) tiny syscall abstract layer

arinc_429

Types and constants for ARINC 429 communication

logz

Zephyr RTOS logging implementation

lilbig

swapping the byte-order of in-memory types

winter-math

Math library for the Winterfell STARK prover/verifier

unix_str

Unix-compatible strings regardless of platform

page-table

Encapsulation of the page table for common architectures

constmuck

const-equivalents of bytemuck functions

numid

A macro for generating structures which behave like numerical id

constdefault

A const Default trait

crt0stack

Tools for reading and creating Linux crt0 stack data

rfc2580

An (enhanced) implementation of RFC 2580

creditcard

Zero-dependency credit card parser and validator

interrupt-bindgen

generate interrupt bindings

mime_typed

More types for mime crate

prealloc

Build time heap-like memory preallocation

variter

Declarative macro-derivable trait for iterating over field-less enum type variants

endiantype

no-std, endian-aware implementation of primitive types like u8, u16, etc

py32-bind-hal

MCU HALs using binding, currently supports PY32

dkb-rs

old bitmap font renderer which supports Latin, Korean and Japanese. Implemented in Rust

concat_const

const &[u8] and &str concatenation

shook

ohook

borrow_trait

Exposes traits for borrow and borrow_mut

as_any_min

A minuscule rust library that allows trait objects to be easily upcast to Any

card10-sys

Unsafe C bindings for card10 l0dables

unaligned

containing types for encapsulating unaligned values

async-let

An experiment based on Conrad Ludgate's musings

stackfmt

Write formatted string to a buffer without alloc

typenum-prime

compile-time primality testing of type-level integers from the typenum crate

stable_try_trait_v2

stable implementation of the Try, FromResidual, and Residual traits under the try_trait_v2 feature

rust-leb128

LEB-128 (varint) encoding

sysfunc-byteorder

Basic compile-time byteorder for various environments #![no_std]

intentionally-empty

An intentionally empty crate

libera

A suite of modular, multidisciplinary, mutually coherent libraries

flatgeom

Geometry types using flat structures instead of jagged arrays

load-buffer

loading data into a fixed-sized buffer. Similar to BufRead, but allowing static or dynamic sizes, and no_std use.

micrortu_ie_base

SDK for MicroRTU

xbadpcm

Free 100% Rust Xbox ADPCM encoder and decoder

castaway

Safe, zero-cost downcasting for limited compile-time specialization

impl_twice

Implement items on two types with only one impl block

seqid

Sequential ID generator traits with some default implementations

manyfmt

Easily create more varieties of formatting than the std::fmt traits offer

non-exhaustive

macro to allow struct expressions of non_exhaustive structs

bitconv

zero-dependency, no_std compatible Rust equivalent to the C# BitConverter class

download_git

Download one or multiple directories from a Git repository

polyval

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

result_float

Floating point type that cannot store NaN

is-prime-for-primitive-int

is_prime for primitive ineger type

bitfield-layout

bitfield handling implementation

nudge

A collection of optimization hints to improve performance

atomic_sync

Atomic-based synchronization implementing traits in abs_sync

modified

Keep track of changes in your variables

tinytest

Write more compact unit tests with a small macro

boxed-slice

An easy abstraction around boxed slices sized by a const generic

atomic_fn

Generic AtomicFnPtr<T> wrapper type for atomic function pointers

peano-axioms

Type-level numbers based on an extension of the Peano axioms

with_closure

Ensure that the noalias optimization takes effect by expanding to closure call

psh

Password generator/manager library that derives deterministic passwords from a set of inputs

achroma

A tiny crate for encoding data related to color vision and color vision deficiency (CVD)

noexcept

Attribute macro equivalent to C++'s noexcept specifier

storage_endian

integer wrappers for explicitly defining storage endianess

fmt-tools

various tools for creating objects that implement Debug and Display traits

phantasm

Small lib that helps with variance

superbitty

A bitfields crate

static_init

Safe mutable static and non const static initialization, and code execution at program startup/exit

uc8151

no_std library for the UC8151(IL0373) e-ink display with embedded-graphics support

ascon-aead

authenticated encryption schemes Ascon-128, Ascon-128a, and Ascon-80pq

ix-rs

A trait for values that permit contiguous subranges

split_array

Split array references in two with compile-time size validation

sdl3-ttf-sys

Low level Rust bindings for SDL3_ttf

initramfs

parser / decoder and encoder of the initramfs (initial ramfs)

storage_zip

functions library for zipping Options and Results into tuples

serde-json-core-fmt

serde-json for no_std programs

packed_booleans

pack booleans together

bool

Straightforward re-useable enum based boolean (which you likely won't need =))

gas-index-algorithm

An unofficial Rust port of Sensirion's gas-index-algorithm

timestamp-source

Timestamp source library provides simple traits for handling timestamps

pui

Process unique identifiers, and abstractions built atop them

vsimd

SIMD utilities

bitflags12

A macro to generate structures which behave like bitflags

chain-trans

chaining function applications onto structs in continuation-style

columns

A text manipulation library for displaying separate text in columns

counter-fpy

Python's Counter module in Rust

cell-ref

Cell type with methods for by-reference mutation

sysfunc-blockcipher-xtea

XTEA block cipher implementation #![no_std]

pkmn-strings

String types for old Pokémon games

x64

UNFINISHED: low-level code for dealing with the x86_64 ISA

bitpack

support no_std environment

wz-utf8

UTF-8 counters for wz

unixconn-rust

Client for library unixconn

tree_ord

An ordering that skips prefixes in tree searches

nanobv

Lightweight no_std-compatible const_fn oriented BitVector implementation

EventEmitter

An EventEmitter object inspired by NodeJS

hodoku

collection of macros to aid diagnostics during testing

runs_inside_qemu

Small no_std-lib that checks if the binary is running inside a QEMU virtual machine. Only works on x86/x86_64 platforms

ident_gen

ident generator

tiny-cli

Tiny cli argparser generator

fields-iter

that allows you inspecting the fields of structs

hamming-lsh

Produces locality-sensitive hashes (LHS) for hamming-space bags of features

array-append

a small family of functions for working with const-generic array types

objstr

File stream abstraction for Rust

tuple-types

that provides the functionality to extract a list of types from a Tuple

heap_arr

[T; N] directly on the heap

iife

A macro with a better syntax for immediately invoked function expressions