Lib.rs

heck

case conversion library

target-lexicon

Targeting utilities for compilers and related tools

libm

libm in pure Rust

const_panic

const panic with formatting

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

opaque-ke

OPAQUE password-authenticated key exchange protocol

ptr_meta

A radioactive stabilization of the ptr_meta rfc

str-buf

Static string buffer

hash32

32-bit hashing algorithms

panic-halt

Set panicking behavior to halt

unicode-properties

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

obfstr

Compiletime string constant obfuscation for Rust

const_soft_float

Const Soft Float Point

typeid

Const TypeId and non-'static TypeId

coolor

conversion between color formats

display-interface

Traits for interfaces used to drive displays

cranelift-entity

Data structures using entity references as mapping keys

wyz

myrrlyn’s utility collection

figlet-rs

FIGlet to create ascii art

serial_int

Safe, easy-to-use auto-increment integers

no-std-compat

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

build-context

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

material-colors

Up-to-date material-color-utilities port

c-scape

A libc bottom-half implementation in Rust

trackball

Virtual Trackball Orbiting via the Exponential Map

coap-message

Interface to CoAP messages

core2

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

limine

parsing the limine boot protocol structures

trimothy

Traits for trimming slices, vecs, and strings

constgebra

Const Linear Algebra

lite-json

JSON parser. Wasm / no_std ready.

origin-studio

An alternative std-like implementation built on origin

hermit-entry

Hermit's loading and entry API

soundchip

Software sinth with configurable channels for authentic sounding virtual sound chips

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.

supply-chain-trust-example-crate-000002

A macro to generate structures which behave like bitflags

nvtx

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

amplify_apfloat

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

no_std_io2

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

efd

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

nowasm

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

js_int

JavaScript-interoperable integer types

bit-struct

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

bitfrob

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

ser-write

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

trim-in-place

In-place trimming strings

riot-wrappers

Rust API wrappers for the RIOT operating system

hostname-validator

Validate hostnames according to IETF RFC 1123

origin

Program startup and thread support written in Rust

department

proposed Storages API

ebds

Messages and related types for implementing the EBDS serial communication protocol

peekmore

Iterator adapter like Peekable, but for peeking forward multiple elements

json-rpc-types

Type definitions for JSON-RPC

as-slice

AsSlice and AsMutSlice traits

erased-discriminant

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

slice_map

A generic container to store a single type of data into unevenly sized slices

handler_table

A lock-free table of event handlers

rawbytes

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

interlock

Readers-writer locks designed for locking intervals

fermium

An opinionated crate of SDL2 bindings

blobby

Iterator over simple binary blob storage

virtio-spec

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

as_variant

macro to convert enums with newtype variants to Options

ser-write-json

JSON serializer for ser-write and deserializer for convenience

indexed-merkle-tree

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

currency-iso4217

ISO 4217 currency codes

atomic-int

Atomics for additional integers, like C/FFI types

kanata-keyberon

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

repr_offset

Offsets of fields for types with a stable layout

package-family-name

calculating MSIX Package Family Name values

gstr

An immutable string implementation optimized for small strings and comparison

array-util

no_std array helpers available without nightly

drawbridge-byte

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

simd-abstraction

Abstract SIMD instruction sets

cranelift-module

Support for linking functions and data with Cranelift

auto-delegate

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

core-error

std::error::Error for libcore

x86-simd

Safe interfaces to x86 and x86_64 SIMD intrinsics

c-enum

A macro to generate c-like enums

constmuck

const-equivalents of bytemuck functions

ezlua

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

mc-sgx-util

shared by SGX libraries

sysml-model

SysML.rs

tuple_len

Get the number of elements in a tuple

bearingpro

solving common maritime navigation tasks

no_std_io

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

assign

macro to allow mutating instance with declarative flavor

cstr_core

CStr and CString for no_std environments

cranelift-bforest

A forest of B+-trees

vga

Support for vga specific functions, data structures, and registers

simple-blit

blitting from one surface to another with some possible transformations

supply-chain-trust-example-crate-000083

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…

stary

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

nairud

xsens-mti

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

miden-client-web

Web Client library that facilitates interaction with the Miden rollup

bind-hal

MCU HALs using binding, currently supports PY32

coordinate-frame

Very simple coordinate frame conversions

squfof

Shanks's square forms factorization

default-option-arr

Macros for simple default initialization of arrays of option types

unix_path

Unix-compatible paths regardless of platform

display-interface-spi

Generic SPI implementation for display interfaces

cpf

Brazilian CPF parsing, validating and formatting library

pid-allocator

PID allocator for no_std environment

os-timer

OS Timers for Rust

micrortu_sdk

SDK for MicroRTU

hashing-serializer

Serialize serde-implementing structures directly into a hash

ac-power

Reference frames and transforms for ac power analysis

array-section

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

reclone

creating a new scope with a set of cloned variables

acolor

Color representations, operations and conversions

utf8-parser

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

spacesuit

Embedded license information

scroll-ring

An MPSC overwriting ring buffer tuned for character data scrollback

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

branch_hints

that provides likely and unlikely branch hint functions in stable Rust

rand_blake3

rand implementations for blake3 types

ssp

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

bit_reverse

Computes the bit reversal of primitive integers

etag

calculation implementation

yatima-core

The core evaluation, typechecking and content-addressing infrastructure of the Yatima Language

can-types

encoding/decoding simple CAN bus data structures

align-address

Functions for aligning addresses

vga-figures

drawing various shapes

staged-builder

A proc macro which generates staged builders for types

human_readable_duration

formatting and parsing human-readable durations

tagptr

Strongly typed atomic and non-atomic tagged pointers

elf_parser_rs

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

nstd-sys

Cross platform general purpose C library written in Rust

ser-write-msgpack

MessagePack serializer for ser-write and deserializer for convenience

line-column

calculate lines and columns of str index

sdl3-src

Source code of the SDL 3 library

intentionally-empty

An intentionally empty crate

supply-chain-trust-example-crate-000034

heck is a case conversion library

rsfuzzymind

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

cbitset

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

bitarray

A const generics driven bit array specialized for hamming distance

combinatory

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

figleter

FIGlet to create ascii art. With kerning.

abs_mm

Abstract Memory Management

softfloat

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

ms_to_secs

convert milliseconds to seconds

satsnet-io

I/O traits for no-std (and std) environments

x2apic

interface to the x2apic interrupt architecture

const-generic-alignment

Const-generic-aligned ZST

coap-message-implementations

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

b2histogram

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

allocandrescu

A collection of various allocators and allocator combinators

multiboot2-common

Common helpers for the multiboot2 and multiboot2-header crates

icao-units

Units for air navigation as defined in ICAO Annex 5

cbitmap

A conventional, compact and core (no_std) bitmap

str-concat

Concatenate two adjacent string slices

nethost-sys

FFI bindings for nethost

supply-chain-trust-example-crate-000052

offset_of functionality for Rust structs

predicator

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

sallyport

API for the Enarx hypervisor-microkernel boundary

manyzip

Zip an arbitrary number of iterables

panic-ext

Extension library to panic facilities to make it more usable

allocator-fallback

Minimal fallback for the standard library’s allocator API

rel-ptr

building movable self-referential types

atomic_sync

Atomic-based synchronization implementing traits in abs_sync

branches

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

konst_kernel

Foundational const functionality shared between konst and const_panic

smooth-buffer

ring buffer that can average values without iterating

x86-alignment-check

x86 aligment check flag manipulation

kvs

Embedded Key-Value Store

abs_buff

ABStraction of BUFFered IO

igvm_defs

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

dyspxkrypt-libuefi

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

sysml-parser

SysML.rs

miden-rpc-proto

Miden node RPC message definitions

const-bitfield

Macros for generating bitfield-like structures with const support

card10-l0dable

make l0dables for the Card10 (CCCamp 2019) badge

rcelebrone_functions

Apenas um teste no curso de rust

uwasm

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

rust-leb128

LEB-128 (varint) encoding

woke

A minimalistic waker implementation for executors

rssafecircuit

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

abler

Tiny type to process various ablers/flags/etc as one

array-tools

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

flags

A macro to generate structures which behave like bitflags

shook

ohook

mm_ptr

Smart pointers implementing abs_mm

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

copic_colors

Copic color list

eint

Fixed-size signed/unsigned big integers

align-data

Simply increase the alignment of any statics or include_bytes!

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

checks

Adds several compile time checks for const generics

const_closure

Helpers for creating const callable closures

coap-handler

Interface to CoAP handlers

splitter

A string and slice splitter library

one-shot-mutex

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

fleck

A uf2 font parser

encap_enum

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

alloc-compose

Composable allocator structures for plugging together more powerful allocators

dtb-walker

package for DTB depth-first walking

static-array

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

static-slicing

enhanced slicing and indexing

cranelift

Umbrella for commonly-used cranelift crates

bytecursor

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

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.

primitive_promotion

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

nanval

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

coap-numbers

Constants for the CoAP protocol

kerml

SysML.rs

waterworks

A small library for chaining together computation stage into a pipeline

drop-move

support moving out of drop

compat-no-std

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

tiny-cli

Tiny cli argparser generator

stivale-boot

parsing stivale and stivale 2 structures

lilbig

swapping the byte-order of in-memory types

py32-bind-hal

MCU HALs using binding, currently supports PY32

chek

An assertions library

load-buffer

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

multiconst

destructures an expression into multiple constants

lolid

Minimal UUID implementation

intbits

Easy access to individual bits of integers

soroban-workspace-contract-a-interface

Embedded license information

cpio_reader

read the contents of cpio files

crt0stack

Tools for reading and creating Linux crt0 stack data

unaligned

containing types for encapsulating unaligned values

tracing-serde-wire

Wire types for use with tracing-serde-structured crate

kiam

Better syntax for if/else chains (when!)

bitflags12

A macro to generate structures which behave like bitflags

datafusion_imu

Performs datafusion for 6 or 9 DOF sensors

magic-sys

Declarations for the libmagic C library

vsimd

SIMD utilities

numid

A macro for generating structures which behave like numerical id

camelpaste

A fork of paste using lowerCamelCase (hopefully temporary)

electricui-embedded

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

oakwood

Vector-backed trees

sipmsg

SIP message parser

const-frac

Types for supporting floating point constants

fixed-filters

fixed-point digital filters

result_float

Floating point type that cannot store NaN

pink-json

serde-json for pink programs

array-fu

Construct arrays using simple syntax

concat_const

const &[u8] and &str concatenation

simdprune

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

bool_traits

Use boolean expressions as trait bounds

constdefault

A const Default trait

lite-parser

parser library. Wasm / no_std ready.

strict_result

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

unix_str

Unix-compatible strings regardless of platform

bitfield-layout

bitfield handling implementation

logz

Zephyr RTOS logging implementation

valip

Parsing of ip addresses from bytes representing strings

encrust

Obfuscate data in memory by encrypting it to hide it until needed

arinc_429

Types and constants for ARINC 429 communication

nudge

A collection of optimization hints to improve performance

objstr

File stream abstraction for Rust

saturating

Saturating<T>, an intentionally-saturating arithmetic wrapper

tiny-game-loop

Basis for a framerate-independent game loop. Only contains the calculations, so you could arrange the loop itself however you want.

rfc2580

An (enhanced) implementation of RFC 2580

micrortu_ie_base

SDK for MicroRTU

mime_typed

More types for mime crate

endiantype

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

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

just_prim_int

Primitive integer marker traits

dkb-rs

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

unsafe_unwrap

Unsafely unwrap Result and Option types without checking

abs_sync

Abstraction of synchronization for rust async/await

noexcept

Attribute macro equivalent to C++'s noexcept specifier

testaso

Test alignment, size and offset for structs

visit_any

Macro to generate matcher for Any

async-let

An experiment based on Conrad Ludgate's musings

card10-sys

Unsafe C bindings for card10 l0dables

as_any_min

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

cboritem

Types for serialized CBOR items

bitpatterns

bitwise pattern testing for integers

hamming-lsh

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

is-prime-for-primitive-int

is_prime for primitive ineger type

storage_zip

functions library for zipping Options and Results into tuples

stackfmt

Write formatted string to a buffer without alloc

flags-macro

helper macro for writing bitflags

atools

const generic expr based fixed length array manipulation

crypto-permutation

Permutation based cryptography framework; core traits

sysfunc-byteorder

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

serde_derive-x86_64-unknown-linux-gnu

Precompiled implementation of #[derive(Serialize, Deserialize)]

axio

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

iife

A macro with a better syntax for immediately invoked function expressions

psh

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

page-table

Encapsulation of the page table for common architectures

gat-std

Variants of Rust std traits that use GATs

xbadpcm

Free 100% Rust Xbox ADPCM encoder and decoder

borrow_trait

Exposes traits for borrow and borrow_mut

seqid

Sequential ID generator traits with some default implementations

impl_twice

Implement items on two types with only one impl block

counter-fpy

Python's Counter module in Rust

panic-usb-boot

Set panicking behavior to reset to usb boot inteface

uc8151

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

peano-axioms

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

bitconv

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

download_git

Download one or multiple directories from a Git repository

stable_try_trait_v2

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

fields-iter

that allows you inspecting the fields of structs

modified

Keep track of changes in your variables

manyfmt

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

display-interface-i2c

Generic I2C implementation for display interfaces

psf2

Minimal, unopinionated PSF2 bitmap font parser

base16-palettes

A representation of the Base16 palettes in Rust

klee-rs

A safe KLEE API for Rust

superbitty

A bitfields crate

with_closure

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

typenum-prime

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

ix-rs

A trait for values that permit contiguous subranges

initramfs

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

err-into

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

timestamp-source

Timestamp source library provides simple traits for handling timestamps

aligned_ptr

Wrappers of functions defined in core::ptr and core::slice modules with alignment and null checks

windowed-infinity

data structure representing an infinite sequentially writable u8 vector of which a small view has writes to it preserved. This is primarily useful when implementing CoAP block-wise transfers…

bool

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

ps2-mouse

basic access to a ps2 mouse in x86 environments

gas-index-algorithm

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

pui

Process unique identifiers, and abstractions built atop them

packed_booleans

pack booleans together

boxed-slice

An easy abstraction around boxed slices sized by a const generic

eh

Convert values to bool, kind of like C, eh?

chain-trans

chaining function applications onto structs in continuation-style

btree_error

To avoid duplication, all bforest libs use the same error defined in this crate

columns

A text manipulation library for displaying separate text in columns

cell-ref

Cell type with methods for by-reference mutation

fast_tuple

procedural macro library that provides an easy way to construct and annotate tuples

split_array

Split array references in two with compile-time size validation

sysfunc-blockcipher-xtea

XTEA block cipher implementation #![no_std]

bonsai

Index arithmetic functions for perfect binary trees

associated

A trait for associating enum variants with constants

bitpack

support no_std environment

wz-utf8

UTF-8 counters for wz

EventEmitter

An EventEmitter object inspired by NodeJS

serde-json-core-fmt

serde-json for no_std programs

vecrem

Cursor-like structure for fast iterative removing of elements from a vec

atomic_fn

Generic AtomicFnPtr<T> wrapper type for atomic function pointers

ident_gen

ident generator

nanobv

Lightweight no_std-compatible const_fn oriented BitVector implementation

x64

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

sysml

SysML.rs

tree_ord

An ordering that skips prefixes in tree searches

panic-reset

Set panicking behavior to reset

array-append

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

tuple-types

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

singly

Lightweight "not" thread safe singleton but it depend on the usage though

heap_arr

[T; N] directly on the heap

txn-core

The structs and traits for the txn and async-txn crates

trapper

creating newtypes that don't require ownership of their internal value

simble

symbols: allocation-less strings up to 8 bytes long

py32csdk-hal-sys

PY32 HAL bindings

embedded-rsx

A minimal example library for embedded systems with Rust

uncon

Traits for unchecked conversions between types

type_val

Type-level values

from-enum

derive proc macro for deriving From on enums

simd-blit

Alpha Compositing & SSAA, optionally using SIMD

safemem

Safe wrappers for memory-accessing functions, like std::ptr::copy()

spacetrace

A 3D path solving library

no-stdout

A no_std compatible stdout facade for Rust

control

loop mechanisms

pinned-init

facilitate safe pinned initialization

storage_endian

integer wrappers for explicitly defining storage endianess

linfo

License info

simd-trick

trick the optimizer into generating SIMD instructions

operator-sugar

Makes operator overloading in Rust more concise and intuitive

include_glob

embed files into an executable via glob patterns

cheapalloc

GlobalAlloc hooked up to libc malloc/free, to use an existing CRT heap

goodnight

executing code upon exit

tiny_lib

A tiny library, that implements some useful math functions to be used in no_std projects

alg-grid

Algorithms for pathfinding in a 2D or 3D grid

simple-clock

The simplest clock for the Rust embedded

bytefield

A pure Rust, no-std implementation of bit fields