Lib.rs

target-lexicon

Targeting utilities for compilers and related tools

libm

libm in pure Rust

const_panic

const panic with formatting

assert_matches

Asserts that a value matches a pattern

colorous

Professional color schemes ported from d3-scale-chromatic

core_extensions

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

str-buf

Static string buffer

obfstr

Compiletime string constant obfuscation for Rust

simd-abstraction

Abstract SIMD instruction sets

wyz

myrrlyn’s utility collection

hash32

32-bit hashing algorithms

fermium

An opinionated crate of SDL2 bindings

figlet-rs

Rust implementation of FIGlet to create ascii art

opaque-ke

An implementation of the OPAQUE password-authenticated key exchange protocol

no-std-compat

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

license

Provides embedded license information from SPDX

elf_rs

A simple no_std ELF file reader for ELF32 and ELF64

js_int

JavaScript-interoperable integer types

tstr

Type-level strings

hexlit

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

coap-message

Interface to CoAP messages

lite-json

Simple JSON parser. Wasm / no_std ready.

core2

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

blobby

Iterator over simple binary blob storage

coolor

conversion between color formats

etag

Simple ETag calculation implementation

safemem

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

const-default

A const Default trait

amplify_apfloat

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

efd

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

ptr_meta

A radioactive stabilization of the ptr_meta rfc

vga

Support for vga specific functions, data structures, and registers

riot-wrappers

Rust API wrappers for the RIOT operating system

trim-in-place

In-place trimming strings

sallyport

API for the Enarx hypervisor-microkernel boundary

json-rpc-types

Type definitions for JSON-RPC

odds

Odds and 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.

trimothy

Traits for trimming slices, vecs, and strings

xsens-mti

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

sorth

Forth inspired interpreted programming language

assign

Simple macro to allow mutating instance with declarative flavor

number-as

Extend primitive number types to make them have a number_as method

panic-halt

Set panicking behavior to halt

woke

A minimalistic waker implementation for executors

mc-sgx-util

Utilities shared by SGX libraries

allocator-fallback

Minimal fallback for the standard library’s allocator API

eint

Fixed-size signed/unsigned big integers

limine

Rust crate for parsing the limine boot protocol structures

serial_int

Safe, easy-to-use auto-increment integers

as-slice

AsSlice and AsMutSlice traits

peekmore

Iterator which can peek forward multiple elements

hermit-entry

RustyHermit's entry API

splitter

A string and slice splitter library

kvs

Embedded Key-Value Store

const-bitfield

Macros for generating bitfield-like structures with const support

display-interface

Traits for interfaces used to drive displays

trackball

Virtual Trackball Orbiting via the Exponential Map

datafusion_imu

Performs datafusion for 6 or 9 DOF sensors

drawbridge-byte

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

evil-janet

Low level bindings to the janet language c api

nanval

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

vsimd

SIMD utilities

magic-sys

Declarations for the libmagic C library

impl-more

Concise trait implementations

page-table

Encapsulation of the page table for common architectures

primitive_promotion

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

interlock

Readers-writer locks designed for locking intervals

multiconst

destructures an expression into multiple constants

lolid

Minimal UUID implementation

electricui-embedded

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

stivale-boot

Rust crate for parsing stivale and stivale 2 structures

yatima-core

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

nairud

mime_typed

More types for mime crate

superbitty

A bitfields crate

crt0stack

Tools for reading and creating Linux crt0 stack data

flipper0

API for Flipper Zero fw

intbits

Easy access to individual bits of integers

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

x2apic

A Rust interface to the x2apic interrupt architecture

xbadpcm

Free 100% Rust Xbox ADPCM encoder and decoder

rel-ptr

A tool for building movable self-referential types

dtb-walker

A simple package for DTB depth-first walking

flipper0-sys

Bindings for Flipper Zero fw

coreclr-hosting-shared

Shared bindings for the coreclr hosting components

coap-message-utils

Utilities for implementing coap-message traits

as_variant

A simple macro to convert enums with newtype variants to Options

is-prime-for-primitive-int

is_prime for primitive ineger type

valip

Parsing of ip addresses from bytes representing strings

nethost-sys

FFI bindings for nethost

kiam

Better syntax for if/else chains (when!)

display-interface-spi

Generic SPI implementation for display interfaces

fields-iter

A crate that allows you inspecting the fields of structs

scope-guard

Simple RAII scope guard

cpio_reader

A library to read the contents of cpio files

bitfrob

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

tuple_len

Get the number of elements in a tuple

uc8151

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

logz

Zephyr RTOS logging implementation

timestamp-source

Timestamp source library provides simple traits for handling timestamps

testaso

Test alignment, size and offset for structs

predicator

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

unix_path

Unix-compatible paths regardless of platform

repr_offset

Offsets of fields for types with a stable layout

constmuck

const-equivalents of bytemuck functions, and more

pink-json

serde-json for pink programs

const-frac

Types for supporting floating point constants

hostname-validator

Validate hostnames according to IETF RFC 1123

bitarray

A const generics driven bit array specialized for hamming distance

serial-num

Serial number type with wraparound

os-timer

OS Timers for Rust

gat-std

Variants of Rust std traits that use GATs

lite-parser

Simple parser library. Wasm / no_std ready.

log-to-defmt

A backend for log that emits through defmt

wz-utf8

UTF-8 counters for wz

constdefault

A const Default trait

tracing-serde-wire

Wire types for use with tracing-serde-structured crate

panic-reset

Set panicking behavior to reset

strict_result

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

bytecursor

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

align-address

Functions for aligning addresses

medusa-proto

Medusa protocol parser

simple_on_shutdown

This crate 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.

acid_io

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

const_closure

Helpers for creating const callable closures

display-interface-i2c

Generic I2C implementation for display interfaces

array-tools

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

psf2

Minimal, unopinionated PSF2 bitmap font parser

coap-message-demos

Demos of the coap-message ecosystem

department

Implementation of the proposed Storages API

align-data

Simply increase the alignment of any statics or include_bytes!

from-enum

Provides a derive proc macro for deriving From on enums

just_prim_int

Primitive integer marker traits

ps2-mouse

This crate provides basic access to a ps2 mouse in x86 environments

zeroable

Provides a derive for bytemuck::Zeroable

cpf

Brazilian CPF parsing, validating and formatting library

drop-move

A Rust library to support moving out of drop

bytefield

A pure Rust, no-std implementation of bit fields

bit_reverse

Computes the bit reversal of primitive integers

unused

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

flags

A macro to generate structures which behave like bitflags

sp-sized-chunks

Fixed length array types for no_std` use within Substrate

numid

A macro for generating structures which behave like numerical id

flags-macro

Provides a helper macro for writing bitflags

epui

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

epsi

Equisized (primitive) signed ints for primitive ints: i8 for u8, i16 for i16, etc

rawbytes

Transtype any sized value to a &[u8]

encap_enum

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

compat-no-std

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

simble

Simple symbols: allocation-less strings up to 8 bytes long