Lib.rs

libm

libm in pure Rust

target-lexicon

LLVM target triple types

hash32

32-bit hashing algorithms

petname

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

spectrum-analyzer

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

average

Calculate statistics iteratively

nc

Access system calls directly

inout

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

seq-macro

Macro to repeat sequentially indexed copies of a fragment of code

unarm

Parses ARM instructions

jni-simple

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

cranelift-module

Support for linking functions and data with Cranelift

font8x8

8x8 monochrome bitmap font for rendering

soundchip

Software sinth with configurable channels for authentic sounding virtual sound chips

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

riot-wrappers

Rust API wrappers for the RIOT operating system

libc-print

println! and eprintln! macros on libc without stdlib

askama_escape

HTML escaping, extracted from Askama

daft

Structural diffs of Rust data structures

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

core2

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

no_std_io2

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

trimothy

Traits for trimming slices, vecs, and strings

c-scape

A libc bottom-half implementation in Rust

figlet-rs

FIGlet to create ascii art

remain

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

virtio-spec

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

micrortu_ie_base

SDK for MicroRTU

ipl3checksum

calculate the IPL3 checksum for N64 ROMs

limine

parsing the limine boot protocol structures

no-std-compat

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

konst_kernel

Foundational const functionality shared between konst and const_panic

force-send-sync

Unsafe wrappers to force Send and Sync

material-colors

Up-to-date material-color-utilities port

earcut

port of the Earcut polygon triangulation library

sdl3-main

Tools for using SDL's main and callback APIs

wary

validation and transformation library

hostname-validator

Validate hostnames according to IETF RFC 1123

js_int

JavaScript-interoperable integer types

lite-json

JSON parser. Wasm / no_std ready.

wyz

myrrlyn’s utility collection

coap-handler-implementations

implementations of CoAP handlers

peekmore

Iterator adapter like Peekable, but for peeking forward multiple elements

nostd

Missing std types for no_std development

xsens-mti

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

ser-write

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

icao-units

Units for air navigation as defined in ICAO Annex 5

movable-ref

building movable self-referential types

wizdraw

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

constgebra

Const Linear Algebra

serial_int

Safe, easy-to-use auto-increment integers

cranelift

Umbrella for commonly-used cranelift crates

opencl-sys

OpenCL C FFI bindings for the Rust programming language

array-util

no_std array helpers available without nightly

package-family-name

calculating MSIX Package Family Name values

mc-sgx-util

shared by SGX libraries

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.

cwextab

CodeWarrior Exception Table decoder

trim-in-place

In-place trimming strings

platforms

Rust platform registry with information about valid Rust platforms (target triple, target_arch, target_os) sourced from the Rust compiler

generativity

Generation of unique invariant lifetimes

omeganum

Stores numbers up to 10{N}9e15

cpio_reader

read the contents of cpio files

axvcpu

Virtual CPU abstraction for ArceOS hypervisor

one-shot-mutex

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

matte

Minimalist and allocation free GUI Layout

as-slice

AsSlice and AsMutSlice traits

assign

macro to allow mutating instance with declarative flavor

display-interface

Traits for interfaces used to drive displays

sub-strs

mser

cwenum

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

pid-allocator

PID allocator for no_std environment

ebds

Messages and related types for implementing the EBDS serial communication protocol

sdl3-src

Source code of the SDL 3 library

interlock

Readers-writer locks designed for locking intervals

cpf

Brazilian CPF parsing, validating and formatting library

encrust

Obfuscate data in memory to hide it until needed

rjw-metoffice

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

semtech_radios

Support for Semtech SX126x and SX128x LoRa radios

repr_offset

Offsets of fields for types with a stable layout

rust-native-obf

advanced native obfuscation library for rust

kiss3d-trackball

Coherent Virtual Trackball Camera Mode for Kiss 3D

atomic-int

Atomics for additional integers, like C/FFI types

pseudo-backtrace

constructing stack-like error chains with caller locations

titanf

Blazingly fast, no_std compatible font rasterizer written in pure Rust

kanata-keyberon

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

amplify_apfloat

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

no_std_io

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

weak_true

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

const-default

A const Default trait

build-context

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

indexed-merkle-tree

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

bit-struct

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

handler_table

A lock-free table of event handlers

literator

Efficient conversion of iterators to human-readable strings

lowpass-filter

first-order digital lowpass filters, compatible with no_std. You can use it, for example, to get the low frequencies from a song.

json-rpc-types

Type definitions for JSON-RPC

bitfrob

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

itermaps

Implement commonly used combinations of Iterator::map

shrewnit

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

unix_path

Unix-compatible paths regardless of platform

tiny-std

Tiny rust stdlib for linux

nvtx

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

etag

calculation implementation

wasmtime-internal-unwinder

INTERNAL: Wasmtime's unwind format and unwinder

efd

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

array-section

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

buildid

Examine the currently running executable to get its build-id or LC_UUID

atools

const generic expr based fixed length array manipulation

noalloc-vec-rs

A no-allocation vector implementation for environment without memory allocation

generic-upper-bound

Stable workaround for internal uses of generic-const-exprs

static-collections

Implementations of fixed-capacity collection types

riscv-h

RISC-V virtualization-related registers

coap-message-implementations

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

core-error

std::error::Error for libcore

cranelift-bforest

A forest of B+-trees

exit-no-std

Cross-platform interface to the process exit function

line-column

calculate lines and columns of str index

vsimd

SIMD utilities

x86-simd

Safe interfaces to x86 and x86_64 SIMD intrinsics

pitchy

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

auto-delegate

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

utf8-parser

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

common_consts

Constants used in daily life

variadic_arguments

Implements variadic arguments into Rust

for-sure

Option-like type but with Deref implementation

replace_self_ty

Macro magic to replace all instances of Self in a token tree

jit-allocator2

An executable code allocator. Fork for jit-allocator

bitut

bit manipulation utilities

magic-sys

Declarations for the libmagic C library

sysml-model

SysML.rs

bitflags-serde-legacy

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

saturating

Saturating<T>, an intentionally-saturating arithmetic wrapper

micrortu_sdk

SDK for MicroRTU

stary

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

x2apic

interface to the x2apic interrupt architecture

bitarray

A const generics driven bit array specialized for hamming distance

bhook

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

const-pkg-version

constant expressions for your package version (no-std/no-alloc compatible)

mod_idiom

mod and use idiom

igvm_defs

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

fbd_sequencer

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

ahrs2

Attitude and heading reference system

apply_if

Conditionally apply a closure to an item or return it

portable_link_section

A portable version of the #[link_section] macro

zodiac

Rust OS framework that offers safe interfaces for kernel development

inc_dec

Incrementation and decrementation in Rust

softfloat

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

smooth-buffer

ring buffer that can average values without iterating

miden-rpc-proto

Miden node RPC message definitions

cbitset

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

ser-write-json

JSON serializer for ser-write and deserializer for convenience

spleen-font

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

dyspxkrypt-libuefi

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

c-enum

A macro to generate c-like enums

rawbytes

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

nowasm

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

generic-array-storage

nalgebra storage implementation backed by generic_array

acid_io

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

nethost-sys

FFI bindings for nethost

nwav

no_std compatible WAV metadata parser

tsl-umd

TSL UMD tally protocol implementation

strip-slice-prefix

A function that strips a prefix from a slice

buffer-trait

A Buffer trait for reading into uninitialized buffers

wasefire-one-of

Macros for mutually exclusive features

page-table-generic

Boot kernel code with mmu

predicator

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

header-vec

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

str-of-bytes

Provide some str functions over owned storage

department

proposed Storages API

mini-loader

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

origin-studio

An alternative std-like implementation built on origin

tato_video

A Fantasy video chip that runs on any potato powered computers. Bring your own back-end!

arm-attr

Reads ARM build attributes of an ELF file

ssp

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

constmuck

const-equivalents of bytemuck functions

pkmn-savedata

Reads and modifies save data for Pokémon games

woke

A minimalistic waker implementation for executors

cstr_core

CStr and CString for no_std environments

kernel-elf-parser

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

rel-ptr

building movable self-referential types

sallyport

API for the Enarx hypervisor-microkernel boundary

os-timer

OS Timers for Rust

bit_reverse

Computes the bit reversal of primitive integers

tuple_len

Get the number of elements in a tuple

multiboot2-common

Common helpers for the multiboot2 and multiboot2-header crates

const-bitfield

Macros for generating bitfield-like structures with const support

smac

A small MAC address parser in no_std Rust

rlwinmdec

PPC Rlwinm/Rlwnm/Rlwimi Decoder Tool

b2histogram

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

card10-l0dable

make l0dables for the Card10 (CCCamp 2019) badge

cbitmap

A conventional, compact and core (no_std) bitmap

uwasm

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

nostd-print

#[no_std] print for Rust on Windows and Unix systems

tagptr

Strongly typed atomic and non-atomic tagged pointers

array-tools

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

ac-power

Reference frames and transforms for ac power analysis

number-as

Extend primitive number types to make them have a number_as method

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

fleck

A uf2 font parser

enumerate-base

Plus the count of Iterator::enumerate by base

gstr

An immutable string implementation optimized for small strings and comparison

noalloc-slip-rs

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

static-slicing

enhanced slicing and indexing

vecxe

functions for vec

dtb-walker

package for DTB depth-first walking

vga

Support for vga specific functions, data structures, and registers

simple-blit

blitting from one surface to another with some possible transformations

noexcept

Attribute macro equivalent to C++'s noexcept specifier

default-option-arr

Macros for simple default initialization of arrays of option types

copic_colors

Copic color list

bind-hal

MCU HALs using binding, currently supports PY32

acolor

Color representations, operations and conversions

can-types

encoding/decoding simple CAN bus data structures

checks

Adds several compile time checks for const generics

anylr

Provide AnyOf<L, R>, SomeOf<L, R>, Either<L, R>, and traits

cdtext

A rough implementation of CD-Text parser

eint

Fixed-size signed/unsigned big integers

solas-lib

Biblioteca de funções do Sola

getrandom

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

errno-no-std

Cross-platform interface to the errno variable

peach_metrics

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

sdl3-ttf-src

Source code of the SDL3_ttf library

bytecursor

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

encap_enum

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

array_chunks

adds array_chunks back in

nanval

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

primitive_promotion

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

display-interface-spi

Generic SPI implementation for display interfaces

str-concat

Concatenate two adjacent string slices

rlibc-ext

A bare-metal library supplying certain libc functions

kerml

SysML.rs

padstate

Tiny structs that hold a game controller's state

allocator-fallback

Minimal fallback for the standard library’s allocator API

nonzero-char

Implement NonZeroChar, like NonZeroU32

alloc-compose

Composable allocator structures for plugging together more powerful allocators

fn-item

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

non-exhaustive

macro to allow struct expressions of non_exhaustive structs

rustdap

firmware crate for DAP-Link on STM32F4xx

kvs

Embedded Key-Value Store

lock_ordering

Lock ordering enforcement at compile time

ser-write-msgpack

MessagePack serializer for ser-write and deserializer for convenience

wmm

WMM no_std library used to calculate the magnetic declination

align-address

Functions for aligning addresses

tato_layout

Minimalist and allocation free GUI Layout

mime_typed

More types for mime crate

if_rust_version

Macro to enable or disable code depending on the rust version

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.

coap-message-demos

Demos of the coap-message ecosystem

stivale-boot

parsing stivale and stivale 2 structures

electricui-embedded

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

hyperscan-tokio-sys

Low-level FFI bindings to VectorScan (Hyperscan fork)

simd-abstraction

Abstract SIMD instruction sets

chek

An assertions library

splitter

A string and slice splitter library

drawbridge-byte

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

intbits

Easy access to individual bits of integers

tiny-cli

Tiny cli argparser generator

panic-reset

Set panicking behavior to reset

typenum-prime

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

aula01

Biblioteca de funções

gen_mcf_macro

A macro working with crate abs_sync v0.2 to generate codes and types needed to implement Future and TrMayCancel for a pattern that supports graceful cancellation in async programming

tiny-start

Tiny start functions and symbol relocation

rand_core_compat

A compatibility layer for different versions of rand_core

cop

Highly efficient first-order connection proving

compat-no-std

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

lolid

Minimal UUID implementation

cboritem

Types for serialized CBOR items

camelpaste

A fork of paste using lowerCamelCase (hopefully temporary)

x86-alignment-check

x86 aligment check flag manipulation

kiam

Better syntax for if/else chains (when!)

panic-abort

Set panicking behavior to abort

bitflags12

A macro to generate structures which behave like bitflags

err-into

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

reclone

creating a new scope with a set of cloned variables

datafusion_imu

Performs datafusion for 6 or 9 DOF sensors

always_send

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

yotta

A no_std arbitrary-precision arithmetic library

waterworks

A small library for chaining together computation stage into a pipeline

axio

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

load-buffer

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

is-photo

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

self-reference

Helper

is-prime-for-primitive-int

is_prime for primitive ineger type

coordinate-frame

Very simple coordinate frame conversions

static-array

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

tracing-serde-wire

Wire types for use with tracing-serde-structured crate

fixed-filters

fixed-point digital filters

result_float

Floating point type that cannot store NaN

sipmsg

SIP message parser

fielder

Efficient and precise bitfields

float-polyfills

Drop-in no_std-compatible polyfills for various f32 and f64 methods

psf2

Minimal, unopinionated PSF2 bitmap font parser

vga-figures

drawing various shapes

rsfuzzymind

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

constdefault

A const Default trait

drop-move

support moving out of drop

unsafe_unwrap

Unsafely unwrap Result and Option types without checking

array-fu

Construct arrays using simple syntax

strict_result

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

bitfield-layout

bitfield handling implementation

micrortu_build_utils

SDK for MicroRTU

gat-std

Variants of Rust std traits that use GATs

r-linux

Capability-based Linux Runtime

x86_vcpu

x86 Virtual CPU implementation for the Arceos Hypervisor

bearingpro

solving common maritime navigation tasks

flatgeom

Geometry types using flat structures instead of jagged arrays

arinc_429

Types and constants for ARINC 429 communication

simdprune

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

numid

A macro for generating structures which behave like numerical id

arrayvec-util

Additional utilities for working with ArrayVec and ArrayString that make it more similar to the standard library

nudge

A collection of optimization hints to improve performance

sa

macro to assert constant expressions

serde-json-core-fmt

serde-json for no_std programs

manyzip

Zip an arbitrary number of iterables

rfc2580

An (enhanced) implementation of RFC 2580

sysml

SysML.rs

logz

Zephyr RTOS logging implementation

stackfmt

Write formatted string to a buffer without alloc

const-generic-alignment

Const-generic-aligned ZST

endiantype

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

valip

Parsing of ip addresses from bytes representing strings

variter

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

sdecay-sys

Bindings to SandiaDecay C++ library along with some helper functions

page-table

Encapsulation of the page table for common architectures

async-let

An experiment based on Conrad Ludgate's musings

borrow_trait

Exposes traits for borrow and borrow_mut

pink-json

serde-json for pink programs

bitpatterns

bitwise pattern testing for integers

card10-sys

Unsafe C bindings for card10 l0dables

unaligned

containing types for encapsulating unaligned values

unwrap_to

macro to unwrap enums

useful_number

that provides useful number types

sha2raw

SHA-2 hash function

sysfunc-byteorder

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

atomic_sync

Atomic-based synchronization implementing traits in abs_sync

dkb-rs

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

just_prim_int

Primitive integer marker traits

lilbig

swapping the byte-order of in-memory types

flags-macro

helper macro for writing bitflags

xbadpcm

Free 100% Rust Xbox ADPCM encoder and decoder

rust-leb128

LEB-128 (varint) encoding

ix-rs

A trait for values that permit contiguous subranges

seqid

Sequential ID generator traits with some default implementations

manyfmt

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

nostd_cow

A no_std implementation of std::borrow::Cow

bitconv

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

download_git

Download one or multiple directories from a Git repository

axdevice_base

Basic traits and structures for emulated devices in ArceOS hypervisor

hamming-lsh

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

figleter

FIGlet to create ascii art. With kerning.

testaso

Test alignment, size and offset for structs

storage_endian

integer wrappers for explicitly defining storage endianess

tinysyscall

a (no depend std) tiny syscall abstract layer

fields-iter

that allows you inspecting the fields of structs

allocandrescu

A collection of various allocators and allocator combinators

modified

Keep track of changes in your variables

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

integral_constant

Type-level wrappers around constant values

atomic_fn

Generic AtomicFnPtr<T> wrapper type for atomic function pointers

align-data

Simply increase the alignment of any statics or include_bytes!

scroll-ring

An MPSC overwriting ring buffer tuned for character data scrollback

gas-index-algorithm

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

with_closure

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

klee-rs

A safe KLEE API for Rust

as_any_min

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

fmt-tools

various tools for creating objects that implement Debug and Display traits

panic-usb-boot

Set panicking behavior to reset to usb boot inteface

superbitty

A bitfields crate

split_array

Split array references in two with compile-time size validation

rand_blake3

rand implementations for blake3 types

const_panic

const panic with formatting

psh

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

storage_zip

functions library for zipping Options and Results into tuples

page-table-arm

arm page table

oakwood

Vector-backed trees

packed_booleans

pack booleans together

counter-fpy

Python's Counter module in Rust

pui

Process unique identifiers, and abstractions built atop them

stable_try_trait_v2

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

btree_error

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

eh

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

is_wine

easily check if the current app is running under wine

columns

A text manipulation library for displaying separate text in columns

sdl3-image-src

Source code of the SDL3_image library

sysfunc-blockcipher-xtea

XTEA block cipher implementation #![no_std]

impl_twice

Implement items on two types with only one impl block

ccarp_helper

A helper crate for CCARP

chain-trans

chaining function applications onto structs in continuation-style

deck-farfalle

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

result-either

Result err variant methods, e.g cloned_err

intentionally-empty

An intentionally empty crate

unix_str

Unix-compatible strings regardless of platform

shook

ohook

rcelebrone_functions

Apenas um teste no curso de rust

bitpack

support no_std environment

vecrem

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

panic-ext

Extension library to panic facilities to make it more usable

tree_ord

An ordering that skips prefixes in tree searches

nanobv

Lightweight no_std-compatible const_fn oriented BitVector implementation

squfof

Shanks's square forms factorization

EventEmitter

An EventEmitter object inspired by NodeJS

ident_gen

ident generator

wz-utf8

UTF-8 counters for wz

objstr

File stream abstraction for Rust

cpumask

CPU mask library in Rust

crt0stack

Tools for reading and creating Linux crt0 stack data

heap_arr

[T; N] directly on the heap

iife

A macro with a better syntax for immediately invoked function expressions

initramfs

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

boxed-slice

An easy abstraction around boxed slices sized by a const generic

yeet-ops

An accompanying library for the experimental do yeet statement in Rust

base16-palettes

A representation of the Base16 palettes in Rust

trapper

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