Lib.rs

heck

case conversion library

target-lexicon

Targeting utilities for compilers and related tools

libm

in pure Rust

assert_matches

Asserts that a value matches a pattern

petname

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

cranelift-entity

Data structures using entity references as mapping keys

const_panic

const panic with formatting

cranelift-module

Support for linking functions and data with Cranelift

core2

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

colorous

Professional color schemes ported from d3-scale-chromatic

hash32

32-bit hashing algorithms

opaque-ke

OPAQUE password-authenticated key exchange protocol

str-buf

Static string buffer

core_extensions

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

obfstr

Compiletime string constant obfuscation for Rust

wyz

myrrlyn’s utility collection

peekmore

Iterator adapter like Peekable, but for peeking forward multiple elements

figlet-rs

FIGlet to create ascii art

ptr_meta

radioactive stabilization of the ptr_meta rfc

const_soft_float

Const Soft Float Point

bit-struct

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

trimothy

Traits for trimming slices, vecs, and strings

ezlua

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

fermium

opinionated crate of SDL2 bindings

origin

Program startup and thread support written in Rust

efd

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

bitmask-enum

bitmask enum attribute macro

copy_from_str

extension trait to copy a string into another string

hexlit

zero-allocation no_std-compatible zero-cost way to convert hex-strings to byte-arrays at compile time

no_std_io

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

trackball

Virtual Trackball Orbiting via the Exponential Map

vga

Support for vga specific functions, data structures, and registers

lite-json

JSON parser. Wasm / no_std ready.

mc-sgx-util

shared by SGX libraries

x2apic

interface to the x2apic interrupt architecture

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.

sallyport

API for the Enarx hypervisor-microkernel boundary

riot-wrappers

API wrappers for the RIOT operating system

as_variant

macro to convert enums with newtype variants to Options

indexed_valued_enums

easily create C-like enums resolving into values

xsens-mti

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

limine

parsing the limine boot protocol structures

nvtx

bindings for the NVIDIA® Tools Extension SDK (NVTX)

softfloat

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

display-interface

Traits for interfaces used to drive displays

rawbytes

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

number-as

Extend primitive number types to make them have a number_as method

cbitmap

conventional, compact and core (no_std) bitmap

coolor

conversion between color formats

const-default

const Default trait

etag

calculation implementation

hermit-entry

RustyHermit's entry API

konst_kernel

Foundational const functionality shared between konst and const_panic

noexcept

Attribute macro equivalent to C++'s noexcept specifier

allocator-fallback

Minimal fallback for the standard library’s allocator API

cstr_core

CStr and CString for no_std environments

cpf

Brazilian CPF parsing, validating and formatting library

branches

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

build-context

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

interlock

Readers-writer locks designed for locking intervals

hostname-validator

Validate hostnames according to IETF RFC 1123

rand_blake3

rand implementations for blake3 types

no-std-compat2

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

c-scape

libc bottom-half implementation in Rust

json-rpc-types

Type definitions for JSON-RPC

constgebra

Const Linear Algebra

kanata-keyberon

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

bitfrob

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

ebds

Messages and related types for implementing the EBDS serial communication protocol

as-slice

AsSlice and AsMutSlice traits

coap-numbers

Constants for the CoAP protocol

trim-in-place

In-place trimming strings

fixed-filters

fixed-point digital filters

simd-abstraction

Abstract SIMD instruction sets

blobby

Iterator over simple binary blob storage

x86-alignment-check

x86 aligment check flag manipulation

c-enum

macro to generate c-like enums

package-family-name

calculating MSIX Package Family Name values

kvs

Embedded Key-Value Store

igvm_defs

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

strict_result

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

no-std-compat

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

encrust

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

ssp

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

intbits

Easy access to individual bits of integers

cbitset

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

js_int

JavaScript-interoperable integer types

acolor

Color representations, operations and conversions

assign

macro to allow mutating instance with declarative flavor

static-slicing

enhanced slicing and indexing

repr_offset

Offsets of fields for types with a stable layout

ix-rs

trait for values that permit contiguous subranges

yatima-core

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

simple-blit

blitting from one buffer to another

os-timer

OS Timers for Rust

storage_endian

integer wrappers for explicitly defining storage endianess

nairud

copic_colors

Copic color list

splitter

string and slice splitter library

rel-ptr

building movable self-referential types

with_closure

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

load-buffer

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

EventEmitter

EventEmitter object inspired by NodeJS

staged-builder

proc macro which generates staged builders for types

serial_int

Safe, easy-to-use auto-increment integers

rawuefi

providing idiomatic raw bindings to UEFI with accordance to UEFI Specification 2.10

heap_arr

[T; N] directly on the heap

amplify_apfloat

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

unix_path

Unix-compatible paths regardless of platform

origin-studio

alternative std-like implementation built on origin

bit_reverse

Computes the bit reversal of primitive integers

download_git

Download one or multiple directories from a Git repository

eint

Fixed-size signed/unsigned big integers

lilbig

swapping the byte-order of in-memory types

predicator

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

soil_moisture_hal

Module for the esp32 series, soil moisture sensor hal. was tested on esp32-c6 and soon on esp32-c3

serde_derive-x86_64-unknown-linux-gnu

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

polymur-hash

Polymur hash function

panic-usb-boot

Set panicking behavior to reset to usb boot inteface

bitarray

const generics driven bit array specialized for hamming distance

intistelecom-rs

intistele.com, you can access and organise SMS mailouts from your own software via API

selfie

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

err-into

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

oakwood

Vector-backed trees

packed_booleans

pack booleans together

psh

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

evil-janet

Low level bindings to the janet language c api

mime_typed

More types for mime crate

seqid

Sequential ID generator traits with some default implementations

const-bitfield

Macros for generating bitfield-like structures with const support

checks

Adds several compile time checks for const generics

atomic-int

Atomics for additional integers, like C/FFI types

nanval

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

woke

minimalistic waker implementation for executors

concat_const

const &[u8] and &str concatenation

bytecursor

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

kiam

Better syntax for if/else chains (when!)

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.

vsimd

SIMD utilities

nethost-sys

FFI bindings for nethost

lolid

Minimal UUID implementation

coap-handler-implementations

implementations of CoAP handlers

currency-iso4217

ISO 4217 currency codes

tagptr

Strongly typed atomic and non-atomic tagged pointers

str-concat

Concatenate two adjacent string slices

tuple_len

Get the number of elements in a tuple

cpio_reader

read the contents of cpio files

primitive_promotion

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

ubus

Work-in-progress: OpenWRT ubus client library in pure Rust

magic-sys

Declarations for the libmagic C library

gas-index-algorithm

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

array-tools

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

stivale-boot

parsing stivale and stivale 2 structures

core-error

std::error::Error for libcore

department

proposed Storages API

const_closure

Helpers for creating const callable closures

manyfmt

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

lock_ordering

Lock ordering enforcement at compile time

common_consts

Constants used in daily life

simd-blit

Alpha Compositing & SSAA, optionally using SIMD

lite-parser

parser library. Wasm / no_std ready.

dtb-walker

package for DTB depth-first walking

scanmut

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

superbitty

bitfields crate

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

drop-move

support moving out of drop

constmuck

const-equivalents of bytemuck functions

ident_gen

ident generator

flags-macro

helper macro for writing bitflags

numid

macro for generating structures which behave like numerical id

acid_io

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

unused

Allows for unused generic parameters that do not act like they are owned

panic-reset

Set panicking behavior to reset

page-table

Encapsulation of the page table for common architectures

tree_ord

ordering that skips prefixes in tree searches

uc8151

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

crt0stack

Tools for reading and creating Linux crt0 stack data

alloc-compose

Composable allocator structures for plugging together more powerful allocators

display-interface-spi

Generic SPI implementation for display interfaces

finalizable

type for finalizable values

integral_constant

Type-level wrappers around constant values

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…

tuple-types

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

unsafe_unwrap

Unsafely unwrap Result and Option types without checking

compat-no-std

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

tstr

Type-level strings

datafusion_imu

Performs datafusion for 6 or 9 DOF sensors

encap_enum

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

sp-sized-chunks

Fixed length array types for no_std` use within Substrate

simble

symbols: allocation-less strings up to 8 bytes long

panic-abort

Set panicking behavior to abort

logz

Zephyr RTOS logging implementation

borrow_trait

Exposes traits for borrow and borrow_mut

arinc_429

Types and constants for ARINC 429 communication

include_glob

embed files into an executable via glob patterns

chek

assertions library

crypto-permutation

Permutation based cryptography framework; core traits

flags

macro to generate structures which behave like bitflags

sipmsg

SIP message parser

lua-sys

Raw Lua 5.3 bindings for Rust, used by Pollua

is-prime-for-primitive-int

is_prime for primitive ineger type

just_prim_int

Primitive integer marker traits

ps2-mouse

basic access to a ps2 mouse in x86 environments

cxx

Safe interop between Rust and C++

scope-guard

RAII scope guard

handler_table

lock-free table of event handlers

card10-sys

Unsafe C bindings for card10 l0dables

timestamp-source

Timestamp source library provides simple traits for handling timestamps

electricui-embedded

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

align-data

Simply increase the alignment of any statics or include_bytes!

pink-json

serde-json for pink programs

testaso

Test alignment, size and offset for structs

saturating

Saturating<T>, an intentionally-saturating arithmetic wrapper

fields-iter

that allows you inspecting the fields of structs

impl_twice

Implement items on two types with only one impl block

valip

Parsing of ip addresses from bytes representing strings

const-frac

Types for supporting floating point constants

as_any_min

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

stackfmt

Write formatted string to a buffer without alloc

constdefault

const Default trait

coap-message

Interface to CoAP messages

bitflags12

macro to generate structures which behave like bitflags

bitpatterns

bitwise pattern testing for integers

endiantype

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

nudge

collection of optimization hints to improve performance

rfc2580

(enhanced) implementation of RFC 2580

storage_zip

functions library for zipping Options and Results into tuples

flips-sys

Raw FFI bindings to Flips, the Floating IPS patcher

encrust-core

Core functionality for the encrust crate

columns

text manipulation library for displaying separate text in columns

tracing-serde-wire

Wire types for use with tracing-serde-structured crate

serde-json-core-fmt

serde-json for no_std programs

b2histogram

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

xbadpcm

Free 100% Rust Xbox ADPCM encoder and decoder

typenum-prime

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

psf2

Minimal, unopinionated PSF2 bitmap font parser

lazyext-slice

Thousands of utility functions for slices and vec

bitconv

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

wz-utf8

UTF-8 counters for wz

trapper

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

bitfield-layout

bitfield handling implementation

drawbridge-byte

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

panic-halt

Set panicking behavior to halt

unaligned

containing types for encapsulating unaligned values

bitpack

support no_std environment

sysfunc-byteorder

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

bool

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

israelid

Israeli ID number validation

dkb-rs

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

gat-std

Variants of Rust std traits that use GATs

btree_error

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

boxed-slice

easy abstraction around boxed slices sized by a const generic

sysfunc-blockcipher-xtea

XTEA block cipher implementation #![no_std]

array-append

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

associated

trait for associating enum variants with constants

vga-figures

drawing various shapes

eh

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

str_split_mut

Little crate implementing some split-like methods on mutable string slices

pui

Process unique identifiers, and abstractions built atop them

align-address

Functions for aligning addresses

chain-trans

chaining function applications onto structs in continuation-style

bonsai

Index arithmetic functions for perfect binary trees

simdprune

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

safemem

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

header-vec

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

modified

Keep track of changes in your variables

simd-trick

trick the optimizer into generating SIMD instructions

type_val

Type-level values

klee-rs

safe KLEE API for Rust

result_float

Floating point type that cannot store NaN

deck-farfalle

Generic Farfalle construction and Kravatte and Xoofff instantiations in the crypto-permutation framework

uncon

Traits for unchecked conversions between types

hamming-lsh

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

fmt-iter

Print all items from an iterator

unix_str

Unix-compatible strings regardless of platform

operator-sugar

Makes operator overloading in Rust more concise and intuitive

cell-ref

Cell type with methods for by-reference mutation

spacetrace

3D path solving library

from-enum

derive proc macro for deriving From on enums

fast_tuple

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

atomic_fn

Generic AtomicFnPtr<T> wrapper type for atomic function pointers

goodnight

executing code upon exit

simple-json2

JSON parser. Wasm / no_std ready.

arraylib

Tools for working with arrays

iia

IntoIterator enabled iterator adapters

highlight

enabling syntax highlighting

nanobv

Lightweight no_std-compatible const_fn oriented BitVector implementation

ac-compose-macros

Macros for creating Substrate extrsinics and rpc calls

atat_derive

Derive macro for atat

genfs

Generic traits, structs and enums for implementing filesystems in no_std environments

squfof

Shanks's square forms factorization

control

loop mechanisms

cnpj

Brazilian CNPJ parsing, validating and formatting library

limine-rs

**Note**: crate name is vacant

static-on-stack

safely promote short-lived references to 'static for the duration of a non-terminating function

ccs811-rs

ams CCS811 Indoor air quality sensor

sensirion-hdlc

Sensirion HDLC implementation

generativity

Generation of unique invariant lifetimes

initramfs

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

bflags

alternative to bitflags

semval

Semantic validation

simple-clock

simplest clock for the Rust embedded

mem_cmp

Memory comparison between types

one-time

Digest-agnostic HOTP and TOTP implementations according to their RFC specifications

aligned_ptr

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

n2k

no_std NMEA 2000 library implemented as an embedded-hal CAN driver

cheapalloc

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

typeenum

Interact with an enum type via traits

sysfunc-dynamac-transmute

Basic cross-feature transmute macro support #![no_std]

badgen

Fast and configurable badge generator

bytefield

pure Rust, no-std implementation of bit fields

array_try_map

Adds a try_map method to arrays

self-reference

Helper

ticklock

Duration, Instant, Frequency abstraction for embedded

wz-core

Core traits for wz

libvmm

Virtual Machine Monitor

simple-hex

ASCII hex-to-bytes-and-back library

asrefmut

Trait which combines AsRef and AsMut

epui

Equisized (primitive) unsigned ints for primitive ints: u8 for u8, u16 for i16, etc

inconceivable

inconceivable! is a macro which closely parallels std::unreachable, or std::panic. The primary difference is that when this crate is configured with the ub_inconceivable option it will emit…

vecrem

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

bit_collection

trait for iterating over the individual bits of a collection

conreg

Control and Regulation

no_alloc

Embedded friendly pointer types for applications without heap allocators

type_traits

Collection of utilities related to types and their properties

howwide_utf8

tiny crate to take the first byte of a character, and use said byte to determine the width of said character

coreclr-hosting-shared

Shared bindings for the coreclr hosting components

pinned-init

facilitate safe pinned initialization

alg-grid

Algorithms for pathfinding in a 2D or 3D grid

tiny_lib

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

with_drop

Nostd wrapper for using a closure as a custom drop function

ntcall

calling NT System Calls easily

powerfmt

powerfmt is a library that provides utilities for formatting values. This crate makes it significantly easier to support filling to a minimum width with alignment, avoid heap…

qed

Compile-time assertions

safe_transmute_2

safe-guarded transmute which aims for a good,short and extensible API

wire4

Embeddable, Forth inspired virtual machine suitable for #![no_std] environments

no-stdout

no_std compatible stdout facade for Rust

synctools

Synchronization tools for no_std

c_utf8

UTF-8 encoded C string types

drogue-nom-utils

Bits and bobs common to many nom parsers

virtio-drivers

VirtIO guest drivers

auto-delegate

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

core-serde-json

serde-json for no_std programs

static_init

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

display-interface-parallel-gpio

Generic parallel GPIO interface for display interfaces

sa

macro to assert constant expressions

kfl-derive

derive implementation for kfl KDL parser

core_io

copy of libstd::io with all the parts that don't work in core removed. Most importantly, it provides the Read and Write traits. This crate is (mostly) automatically generated from the rust git source…

typsy

Heterogenous containers

permutation-keccak

Keccak-f and keccak-p permutations in the crypto-permutation framework

fontsdf

fontdue extension to generate sdf:s directly

pui-vec

append only vector, with guaranteed elided bounds checks

checkmail

Email Validation Library

cranelift

Umbrella for commonly-used cranelift crates

soild-moister-test

Module for esp32c6 soil moisture sensor

x86_64

Support for x86_64 specific instructions, registers, and structures

owned-singleton

Owned singletons

scroll-ring

MPSC overwriting ring buffer tuned for character data scrollback

consume_on_drop

zero-cost abstraction that allows Drop::drop to consume self by value

parse_binary

Parse binary data, without std, and without allocation

the_assoc_ty_ext

Canonical associated type (as in New Type idiom)

ignore-result

Adds a Result<_, _>.ignore() method to ignore the return value of a function call without panicking in case of error

hex2bytearray

convert hexadecimal strings to byte-arrays

partial_application

partial function application via the partial! macro

camelpaste

fork of paste using lowerCamelCase (hopefully temporary)

elain

Set a type's minimum alignment with const generics

ruspiro-lock

Providing Spinlock, Semaphore and mutual exclusive data access for cross core usage on Raspberry Pi

panic-never

guarantees that your application is free of panicking branches

hex-display

Display impl for byte slices which provides a hexdump

tiny-cli

Tiny cli argparser generator

mcp2515

#![no_std] library for interacting with MCP2515 CAN controller chips

infrared

remote control library

bad

Unlicensed bad ideas

try-drop

Batteries included error handling mechanisms for drops which can fail

enum-repr

Derive enum repr conversions compatible with type aliases

qemu-fw-cfg

reading fw_cfg from QEMU

sps30

Sensirion SPS30 Particulate Matter Sensor

labrador-ldpc

Encoders and decoders for CCSDS LDPC error correcting codes

tagged-box

Box that uses tagged pointers

nclosure

composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable

array-fu

Construct arrays using simple syntax

hamming-dict

Generates codeword dictionaries for hamming-space BoW algorithms

usbd-human-interface-device

Batteries included embedded USB HID library for usb-device. Includes concrete Keyboard (boot and NKRO), Mouse, Joystick and Consumer Control implementations as well as support for building your own HID classes.

primitive_traits2

implements traits for primitives as Unsigned and RawPointer

card10-l0dable

l0dables for the Card10 (CCCamp 2019) badge

wdk-panic

Default panic handler implementations for programs built with WDK

random_struct_layout

custom attributes to randomize struct members layout

benchmark-simple

tiny, super simple and portable benchmarking library

usize_cast

Compile time checked cast from and to usize/isize

mpu6050-dmp

Platform-independent I2C driver for MPU6050. Supports DMP usage. Fork of drogue-mpu-6050 which uses only embedded-hal traits (no dependency on embedded-time or drogue-embedded-timer).

microasync

Very small async runner

stdint

C99 stdint/stdio types for easier interop

lgio

Lightweight, generic, no_std IO

ruspiro-arch-aarch64

access to Aarch64 system registers as well as specific usefull aarch64 assembly instructions

executor

minimalistic async/await executor

complete-pic

complete interface for the legacy 8259 PIC and the newer APIC

st7306

TFT LCD driver with embedded-graphics support

postcard

no_std + serde compatible message library for Rust

miniarg

minimal argument parser, with support for no-std and no-alloc

sorth

Forth inspired interpreted programming language