Lib.rs

getrandom

A small cross-platform library for retrieving random data from system source

libm

libm in pure Rust

libc

Raw FFI bindings to platform libraries like libc

target-lexicon

LLVM target triple types

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

branches

Branch hinting prediction and control functions for stable Rust including likely, unlikely, assume and abort, plus read and write cpu prefetch functions to help algorithm optimization

pastey

Macros for all your token pasting needs. Successor of paste.

figlet-rs

FIGlet to create ascii art

generativity

Generation of unique invariant lifetimes

dcv-color-primitives

perform image color model conversion

inout

Custom reference types for code generic over in-place and buffer-to-buffer modes of operation

trim-in-place

In-place trimming strings

const_panic

const panic with formatting

page-table-generic

Generic page table walk and map

hash32

32-bit hashing algorithms

wyz

myrrlyn’s utility collection

nc

Access system calls directly

seq-macro

Macro to repeat sequentially indexed copies of a fragment of code

jni-simple

binding for JNI (Java Native Interface) and JVMTI (JVM Tool Interface)

cranelift-module

Support for linking functions and data with Cranelift

no_std_io2

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

earcut

port of the Earcut polygon triangulation library

daft

Structural diffs of Rust data structures

no-std-compat

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

font8x8

8x8 monochrome bitmap font for rendering

average

Calculate statistics iteratively

audio-codec

A collection of VoIP audio codecs in pure Rust, including G.711, G.722, G.729, and Opus

sdl3-main

Tools for using SDL's main and callback APIs

lowpass-filter

High performance no_std lowpass filter for digital signal processing. A simple first-order digital filter with a SIMD-accelerated slice API, no dependencies, no unsafe code, and no allocations.

libc-print

println! and eprintln! macros on libc without stdlib

unarm

Parses ARM instructions

limine

Rust interface for the Limine boot protocol

ax-io

std::io for no_std environment

soundchip

Software sinth with configurable channels for authentic sounding virtual sound chips

whippyunits

A zero-cost, pure rust units-of-measure library for applied computation

x86_vcpu

x86 Virtual CPU implementation for the Arceos Hypervisor

coap-message-implementations

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

cranelift

Umbrella for commonly-used cranelift crates

media-plane

ingress/egress spine for a live media origin: Dialer/Listener -> byte stages -> IngestSession -> Trunk (bounded sample/segment/event/part rings with cursor subscribers), three egress shapes (served/push/segment)…

micrortu_ie_base

SDK for MicroRTU

cyber-hemera

Hemera — Poseidon2 hash over Goldilocks field

miden-serde-utils

Serialization/deserialization utilities for the Miden project

dpp-rules

Pure EU ESPR cross-field regulatory rules, shared by dpp-domain and the Wasm product group plugins

ipl3checksum

calculate the IPL3 checksum for N64 ROMs

trimothy

Traits for trimming slices, vecs, and strings

daemonic_error

Errors that compose, predict, and leave receipts - Compose: algebraic combination (in active development) - Predict: Glass/Severity - Receipts: audit trail, position, checksum - Reflection:…

remain

Compile-time checks that an enum, struct, or match is written in sorted order

askama_escape

HTML escaping, extracted from Askama

rawbytes

View Rust values as byte slices without copying or allocation, with no_std support

paperpaw-plugin-menu

PaperPaw menu overlay: shows the entries any plugin contributes to a menu

build-context

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

io-replica

Offline-first replica engine library for Rust

aequitas

Atlas physical-quantity and dimensional-law foundation

thorvg

Safe Rust bindings to the ThorVG vector graphics library

konst_kernel

Foundational const functionality shared between konst and const_panic

ser-write

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

tyche-core

Core reproducible uncertainty-study laws for Tyche

kanata-keyberon

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

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

sdl3-src

Source code of the SDL 3 library

bitflags-lite

Lightweight generics-based bitflags

hostname-validator

Validate hostnames according to IETF RFC 1123

cranelift-bforest

A forest of B+-trees

lazy_importer

Rust port of Justas Masiulis's lazy_importer for Windows module and export resolution

hashing-serializer

Serialize serde-implementing structures directly into a hash

tiny-std

Tiny rust stdlib for linux

staged-builder

A proc macro which generates staged builders for types

oxiephemeris-analytic

OxiEphemeris: Pure Rust ephemeris engine (analytic fallback: truncated VSOP87E planets + ELP2000-82B Moon, no data files)

gnat

Type-level numbers without extra bounds

peekmore

Iterator adapter like Peekable, but for peeking forward multiple elements

dreid-kernel

A high-performance, no-std Rust library providing pure mathematical primitives and stateless energy kernels for the DREIDING force field

cwextab

CodeWarrior Exception Table decoder

cwenum

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

dsfb-debug

— Structural Semiotics Engine for Software Debugging. A deterministic, read-only, observer-only augmentation layer for execution-trace residual interpretation. Does NOT replace existing…

icao-units

Units for air navigation as defined in ICAO Annex 5

virtio-spec

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

lambert_izzo

Izzo's revisited Lambert solver (single & multi-rev, short & long way), no_std-friendly

orfail

Error handling library for portable unrecoverable errors

wary

validation and transformation library

cosmo-compat

Libc shims where Cosmopolitan and Rust's std disagree — link it into a cosmo target and the fixes apply themselves

nostd

Missing std types for no_std development

js_int

JavaScript-interoperable integer types

interrupts

Cross-architecture utilities for temporarily disabling interrupts

wasmtime-internal-unwinder

INTERNAL: Wasmtime's unwind format and unwinder

titanf

Fast, safe, no_std font rasterizer written in Rust

kernel-elf-parser

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

crunch64

handling common compression formats for N64 games

package-family-name

calculating MSIX Package Family Name values

as-slice

AsSlice and AsMutSlice traits

sequents

Multiplicative-additive linear System L with exponentials, embedded in Rust's type system

line-column

calculate lines and columns of str index

material-colors

Up-to-date material-color-utilities port

optica

Fast participating-media and optics foundation: typed rays, optical coefficients, phase functions, spectra, and optical-depth integration

dynoffsets

Resolve engine struct offsets, module-global pointers, registered interfaces and button-state addresses from a running target process at call time, with compile-time fallback literals…

ssai-runtime

Sans-IO SCTE-35 SSAI session core: per-session ad-break state, a pluggable ad-decision trait, splice-point conditioning, and per-session HLS Interstitial playlist rendering. No HTTP, no ad-decision client. no_std.

axivc

Shared-memory protocol helpers for AxVisor inter-VM communication

encrust

Obfuscate data in memory to hide it until needed

virtio-accel-conformance

Reusable semantic conformance suite for virtio-accel backends

allocator-fallback

Minimal fallback for the standard library’s allocator API

vsimd

SIMD utilities

axdevice_base

Basic traits and structures for emulated devices in ArceOS hypervisor

nonzero_macros

Macros for compile-time checked NonZero integers and safe NonNull pointer creation in no_std environments

tagptr

Strongly typed atomic and non-atomic tagged pointers

multiboot2-common

Common helpers for the multiboot2 and multiboot2-header crates

hekate-crypto

Hash abstraction for the Hekate ZK proving system: Blake3, SHA-256, SHA-3-256

paperpaw-plugin-weather

PaperPaw weather: the weather now and the next days as widgets, from Open-Meteo

rand_core_compat

A compatibility layer for different versions of rand_core

opt-level

Get value of rustc -Copt-level= flag

literator

Efficient conversion of iterators to human-readable strings

saorsa-logic

Pure logic crate for Saorsa network - zkVM compatible, no_std

soma-som-core

Consolidated into soma-som-ring (single-crate ring substrate). No code ships here.

b2histogram

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

bit-struct

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

glob-matcher

A no_std fork of glob-match – fast glob pattern matching

zerodds-corba-codegen

The CORBA 3.3 Annex A.1 special types and the stub and skeleton mappings, over the common AST: which of the thirteen a model type is, and what each language PSM calls it

paperpaw-plugin-browser

PaperPaw browser: reads web pages like books and fetches books and fonts from the web

febug

anyway, here's user-space debugfs

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.

rich_range

Range calculation helper

opencl-sys

OpenCL C FFI bindings for the Rust programming language

serial_int

Safe, easy-to-use auto-increment integers

itermaps

Implement commonly used combinations of Iterator::map

space-units

Type-safe units of measure for aerospace quantities

interlock

Readers-writer locks designed for locking intervals

gfx_types

Core graphics types shared between kernel and userspace - RedstoneOS

semtech_radios

Support for Semtech SX126x and SX128x LoRa radios

addended_ordered_map

Ordered mapping with ranged lookups. Range sizes can be modified after creation.

assign

macro to allow mutating instance with declarative flavor

os-id

OS ids abstractions for process and thread

waddling-sequences

Standard WDP-6 compliant sequence constants for consistent diagnostic codes across the Waddling ecosystem

static-collections

Implementations of fixed-capacity collection types

usize-conv

Infallible integer conversions to and from usize and isize under explicit portability guarantees

address_space

working with MIPS address spaces, providing types for managing ROM and VRAM addresses, sizes, and ranges

rmquickjs

High-level MicroQuickJS bindings for Rust

staticview

Turn any borrowed struct into a self-owning 'static version — all slice data packed into a single heap allocation, no cloning strings into String, no Vec overhead. Just raw, flat memory.

buffer-trait

A Buffer trait for reading into uninitialized buffers

ars

URL library based on Web Standards

omeganum

Stores numbers up to 10{N}9e15

pso-vdf

no_std Verifiable Delay Function: MinRoot over BLS12-381 with Wesolowski O(1) verify

bittersweet

Add more intentional predicates to bitwise calcs

x2apic

interface to the x2apic interrupt architecture

coap-handler-implementations

implementations of CoAP handlers

cpumask

CPU mask library in Rust

c-enum

A macro to generate c-like enums

static-array

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

array-util

no_std array helpers available without nightly

dshot-frame

Generates frames for the DShot ESC protocol

lite-json

JSON parser. Wasm / no_std ready.

bitflags-serde-legacy

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

align-address

Functions for aligning addresses

atomic-int

Atomics for additional integers, like C/FFI types

no_std_io

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

uor-prism-fhe

Prism standard-library homomorphic-encryption sub-crate (wiki ADR-031): declares FheAxis under the axis! SDK macro with a reference XOR-additive scheme suitable for conformance testing

matte

Minimalist and allocation free GUI Layout

etag

calculation implementation

unicode-consts

named constants for all unicode characters

noalloc-vec-rs

A no-allocation vector implementation for environment without memory allocation

utf8-parser

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

shrewnit

extendable, no_std, no_alloc, and 100% Rust units library

winget-types

WinGet Types

nostd_cow

A no_std implementation of std::borrow::Cow

lilbig

swapping the byte-order of in-memory types

ckb-opt-fips202

Optimized FIPS202 (SHAKE256) implementation for CKB-VM with Rust bindings

lez-approval

Agnostic single-admin approval library for LEZ programs (RFP-001)

rlibc-ext

A bare-metal library supplying certain libc functions

codata

A lightweight Rust crate providing CODATA 2022 physical and IAU 2015 astronomical constants

obfany

Compiletime string, number, and boolean constant obfuscation for Rust

nairud

qoa

A pure, no dependency, no_std rust QOA audio decoder and encoder

cpio_reader

read the contents of cpio files

bitarray

A const generics driven bit array specialized for hamming distance

better_option_result

A better Option/Result alternative

irid-syscall

bindings for system calls for the irid kernel

bytes-pool

Allocation-free sharing of bytes and strings using Bytes as storage

core-error

std::error::Error for libcore

heap_arr

Allocate fixed-size arrays directly on the heap, bypassing stack allocation limits

const-default

A const Default trait

leaffall

Lightweight library for staged graceful shutdown

movable-ref

building movable self-referential types

limine-protocol-for-rust

Limine Boot Protocol in kernel binaries

pocket-raster

Deterministic DrawList software rasterization for PocketJS

micrortu_sdk

SDK for MicroRTU

jmp-scape

Safe Rust access to setjmp and sigsetjmp, forked from cee-scape

nimage

imaging library

simpleos

OS use for MCU, that implements single-threaded asynchronous runtime

hekate-core

Core primitives for the Hekate ZK proving system

generic-array-storage

nalgebra storage implementation backed by generic_array

dsfb-chemical-engineering-corpus

Chemical-engineering soft-sensor data CORPUS for DSFB-Chemical-Engineering: a provenance-bound, deduplicated, deterministic catalogue of public soft-sensor datasets (cheap sensors -> hard-to-measure…

force-send-sync

Unsafe wrappers to force Send and Sync

pid-allocator

PID allocator for no_std environment

mh-locator

representing Maidenhead locators

edlcodegen-core

Internal core types and utilities shared by edlcodegen host and enclave support crates

semx_target_define

seminix 项目统一管理跨平台编译器 target 三元组

rotate_backup

Rotate you backups easily

fluidattacks-blends-domain

Blends functional core: pure AST graph to syntax graph (no_std)

libcplusplus

A no_std reimplementation of LLVM's libc++ in Rust with ABI-compatible C++ standard library types and a built-in memory sanitizer

origin-studio

An alternative std-like implementation built on origin

squib-arch

aarch64 layout, ESR_EL2 decoder, PSCI dispatch, sysreg subset, and IntId newtype for squib

returns

temporary return macros to let the compiler shut the fun up while building

salps

random string generation

sdl3-image-src

Source code of the SDL3_image library

nowasm

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

anvil-sys

Raw bindings to the Anvil plugin API 2 and its services, the C ABI of the Anvil plugin loader for Europa Universalis IV

constmuck

const-equivalents of bytemuck functions

generic-upper-bound

Stable workaround for internal uses of generic-const-exprs

nethost-sys

FFI bindings for nethost

wizdraw

Portable crate to fill and stroke composite bezier curves (paths)

libwildnix

Official userspace library for the WildNIX operating system

playout-runtime

Sans-IO linear channel playout: a schedule model (programme/ad/slate), transition planning across a join (PTS-rebase offset + discontinuity detection), and SCTE-35 splice_insert() emission…

ahrs2

Attitude and heading reference system

pseudo-backtrace

constructing stack-like error chains with caller locations

unicode-id-trie-rle

Unicode identifier (UAX #31) checker using a deduplicated trie with run-length encoded leaves

riscv-h

RISC-V virtualization-related registers

wasefire-one-of

Macros for mutually exclusive features

constgebra

Const Linear Algebra

json-rpc-types

Type definitions for JSON-RPC

bitwisdom

Bit manipulation in Rust, no-std, no-unsafe, const support

display-interface

Traits for interfaces used to drive displays

saturating

Saturating<T>, an intentionally-saturating arithmetic wrapper

kobe-vault

Versioned AES-256-GCM envelope encryption and key derivation for Kobe

sigshift

Unconventional conversions between signed and unsigned types

bytestringmut

Mutable manipulation of ByteStrings

ts_peercapability

tailscale peer capability definitions

peach_metrics

Low level CPU and OS timing functions for instrumention-based profiling

dyspxkrypt-libuefi

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

mini-loader

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

your_literals

ability to define constants and their corresponding macros using literals

libbsd-sys

Raw FFI bindings to libbsd

tidecoin-io

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

paperpaw-plugin-reading-goal

PaperPaw reading goal: minutes to read a day, and a cat on the home screen whose mood follows today's reading

fluidattacks-gitlab-sdk-rs-domain

GitLab SDK functional core: pure types (no I/O)

sp1-ntt-gadget

NTT/INTT Custom Gadget for Dilithium (ML-DSA-65) verification in SP1 zkVM with 60-bit soundness PIC

ansi-term-styles

ANSI terminal escape code constants for styling text

yatima-core

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

xsens-mti

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

handler_table

A lock-free table of event handlers

agentidemp

Idempotency keys for LLM agent retries. Deterministic content-derived keys (UUIDv5 or sha256-hex) so retries dedupe at the provider.

noun

Content-addressable 32-byte identifiers for immutable Merkle proofs

non-exhaustive

macro to allow struct expressions of non_exhaustive structs

bitfrob

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

generator-light

Light stackless generators based on Futures

softfloat

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

unix_path

Unix-compatible paths regardless of platform

efd

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

paperpaw-plugin-joplin

PaperPaw Joplin: a book's exported highlights and notes kept as a note in Joplin

chiptunomatic

Deterministic chiptune generator from binary input (WASM-compatible library)

page-table

Encapsulation of the page table for common architectures

stary

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

saorsa-attestation-guest

SP1 zkVM guest program for Saorsa Entangled Attestation proofs

size-convert

Conversions to and from Rust's machine-dependent integer types, usize and isize

ebds

Messages and related types for implementing the EBDS serial communication protocol

magic-sys

Declarations for the libmagic C library

fbd_sequencer

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

fiducial-mesh

no_std case generation from a board outline: gasket-sealed base/lid/gasket, connector cutouts, standoffs, fasteners; binary STL + GLB export

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

amplify_apfloat

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

wayland-oxide

Pure rust wayland implementation supporting no_std and io-uring

prrng

psuedo-random number generation

woke

A minimalistic waker implementation for executors

iter-chain-exact

Like Iterator::chain, but implemented ExactSizeIterator

repr_offset

Offsets of fields for types with a stable layout

oxigeo-noalloc

no_std, no_alloc fixed-size geometry primitives for OxiGeo

x86-simd

Safe interfaces to x86 and x86_64 SIMD intrinsics

paperpaw-plugin-opds

PaperPaw OPDS catalogs: browse, search and download books, and keep folders in sync with catalogs

asm_att

Macros that makes the assembly writing of ATT syntax a bit more convenient

framebuffer-draw

Draw pixels on a raw framebuffer

ser-write-json

JSON serializer for ser-write and deserializer for convenience

department

proposed Storages API

arm-attr

Reads ARM build attributes of an ELF file

gstr

An immutable string implementation optimized for small strings and comparison

apply_if

Conditionally apply a closure to an item or return it

igvm_defs

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

rjw-metoffice

Rust bindings to the Met Office Global Spot site-specific weather API

securanido-platform

Reserved brand name in the nido ecosystem; canonical source https://github.com/nash87/nido

cbitmap

A conventional, compact and core (no_std) bitmap

predicator

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

smol-base-x

no-std centric implementation of base-x

coap-numbers

Constants for the CoAP protocol

rel-ptr

building movable self-referential types

const-bitfield

Macros for generating bitfield-like structures with const support

array-tools

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

mdr14

Measure the pleasure of your music in everyone's favourite language

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

simple-blit

blitting from one surface to another with some possible transformations

auto-delegate

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

uor-prism-verify

The Prism replay façade: a thin verification surface re-exporting certify_from_trace, Certified, and the wire-format types defined by uor-foundation

one-shot-mutex

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

tuple_len

Get the number of elements in a tuple

card10-l0dable

make l0dables for the Card10 (CCCamp 2019) badge

sallyport

API for the Enarx hypervisor-microkernel boundary

uwasm

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

cpf

Brazilian CPF parsing, validating and formatting library

static-slicing

enhanced slicing and indexing

ac-power

Reference frames and transforms for ac power analysis

hkd32

HMAC-based Hierarchical Key Derivation: deterministically derive a hierarchy of symmetric keys from initial keying material through repeated applications of the Hash-based Message Authentication Code…

weak_true

Similar to the automatic implicit conversion to boolean values in weakly typed languages

noalloc-slip-rs

A no-std SLIP (Serial Line Internet Protocol) encoder and decoder implementation

ckb-opt-sha512

Optimized SHA-512 implementation for CKB-VM with Rust bindings

intomind-model

The IntoMind on-device encoder, as a library: the device's arithmetic, exactly. The encoder's weights are not published.

ax-cpumask

CPU mask library in Rust

fluidattacks-core-contextualizes-domain

Fluid Attacks contextualizes functional core (no_std)

acid_io

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

checks

Adds several compile time checks for const generics

compat-no-std

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

itym_util

Dependency of other Itym crates

dsfb-chemical-engineering-atlas

Finite, curated AUTHORITY crate for DSFB-Chemical-Engineering: the canonical chemometric detector records and the H1-H6 process-residual heuristic records, with deterministic validation gates and…

mc-sgx-util

shared by SGX libraries

geiserx_ts_capabilityversion

tailscale capability version definition

vga

Support for vga specific functions, data structures, and registers

header-vec

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

minicbor-adapters

Adapters between minicbor and other crates such as heapless and cboritem

str-concat

Concatenate two adjacent string slices

copic_colors

Copic color list

pitchy

Minimalistic Rust library for working with frequencies (Hz), MIDI numbers, musical notes, and pitch operations like transposition and octave shifts

fleck

A uf2 font parser

ps-jxl-oxide-common

Common helpers for jxl-oxide: pathscale fork of jxl-oxide

rust-native-obf

advanced native obfuscation library for rust

ts_nodecapability

tailscale node capability definitions

drawbridge-byte

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

vbsenclave-sdk-enclave

Enclave-side Rust SDK for developing applications using Windows VBS enclaves

os-timer

OS Timers for Rust

for-sure

Option-like type but with Deref implementation

spleen-font

A no_std PSF-2 bitmap font loader with Spleen fonts prepackaged

c-scape

A libc bottom-half implementation in Rust

smooth-buffer

ring buffer that can average values without iterating

tiny-start

Tiny start functions and symbol relocation

fiducial-geometry

no_std geometry for Fiducial: points, tolerance profiles, connector envelopes, and ear-clipping triangulation of polygons with holes

atools

const generic expr based fixed length array manipulation

pkmn-savedata

Reads and modifies save data for Pokémon games

hc_functions

Biblioteca de teste

can-types

encoding/decoding simple CAN bus data structures

kvs

Embedded Key-Value Store

bit_reverse

Computes the bit reversal of primitive integers

cstr_core

CStr and CString for no_std environments

sdl3-mixer-src

Source code of the SDL3_mixer library

axvcpu

Virtual CPU abstraction for ArceOS hypervisor

noexcept

Attribute macro equivalent to C++'s noexcept specifier

sysml-parser

SysML.rs

default-option-arr

Macros for simple default initialization of arrays of option types

common_consts

Constants used in daily life

sdl3-mixer-sys

Low level Rust bindings for SDL3_mixer

minimp3-sys

Rust bindings for the minimp3 library

chek

An assertions library

wmm

WMM no_std library used to calculate the magnetic declination

bitsy-script

Interpreter for Bitsy scripting language

axio

std::io for no_std environment

dtb-walker

package for DTB depth-first walking

if_rust_version

Macro to enable or disable code depending on the rust version

tato

A ridiculously obsolete collection of zero-dependency game development modules that can run on any computer, even potato-powered ones!

align-data

Simply increase the alignment of any statics or include_bytes!

sub-strs

gat-std

Variants of Rust std traits that use GATs

smac

A small MAC address parser in no_std Rust

konst_join

macros that make literal concatenation more convenient

send-arc

impl<T: Sync> Send for SendArc<T>

waterworks

A small library for chaining together computation stage into a pipeline

portable_link_section

A portable version of the #[link_section] macro

errno-no-std

Cross-platform interface to the errno variable

intbits

Easy access to individual bits of integers

paperpaw-plugin-menu-editor

PaperPaw menu editor: reorders, removes and adds the entries of every menu on the device

aula01

Biblioteca de funções

load-buffer

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

fixed-filters

fixed-point digital filters

cop

Highly efficient first-order connection proving

ssp

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

coordinate-frame

Very simple coordinate frame conversions

lock_ordering

Lock ordering enforcement at compile time

rsfuzzymind

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

variadic_arguments

Implements variadic arguments into Rust

oxivgl-sys

Raw LVGL v9.5 FFI bindings for oxivgl — compiled from source with bindgen

always_send

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

x86-alignment-check

x86 aligment check flag manipulation

affidavit-core

no_std, forbid(unsafe) reference verifier for affidavit receipt chains that implements zero cryptographic algorithms: ML-DSA-65 and BLAKE3 arrive as external dependencies

download_git

Download one or multiple directories from a Git repository

micrortu_build_utils

SDK for MicroRTU

typenum-prime

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

lolid

Minimal UUID implementation

mime_typed

More types for mime crate

nanval

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

bhook

Lightweight hook crate with no_std support that works on x86, x86_64, arm and aarch64

borrow_trait

Exposes traits for borrow and borrow_mut

is-photo

determine if an image is likely a photograph or a 2D graphic

cbitset

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

datafusion_imu

Performs datafusion for 6 or 9 DOF sensors

bind-hal

MCU HALs using binding, currently supports PY32

self-reference

Helper

encap_enum

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

miden-rpc-proto

Miden node RPC message definitions

atomic_sync

Atomic-based synchronization implementing traits in abs_sync

const-generic-alignment

Const-generic-aligned ZST

abs_sync

ABStraction of SYNchronization

bytecursor

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

djb2

Tiny non-cryptographic checksum algorithm by D. J. Bernstein (1991, u32 XOR variant)

jit-allocator2

An executable code allocator. Fork for jit-allocator

bitut

bit manipulation utilities

panic-reset

Set panicking behavior to reset

simd-abstraction

Abstract SIMD instruction sets

eint

Fixed-size signed/unsigned big integers

nido-tokens

Reserved brand name in the nido ecosystem; canonical source https://github.com/nash87/nido

unwrap_to

macro to unwrap enums

ser-write-msgpack

MessagePack serializer for ser-write and deserializer for convenience

primitive_promotion

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

intentionally-empty

An intentionally empty crate

async-let

An experiment based on Conrad Ludgate's musings

strict_result

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

vga-figures

drawing various shapes

fn-item

Helpers for working with closures that don’t capture any variables

fielder

Efficient and precise bitfields

tiny-cli

Tiny cli argparser generator

card10-sys

Unsafe C bindings for card10 l0dables

kiam

Better syntax for if/else chains (when!)

bitflags12

A macro to generate structures which behave like bitflags