Lib.rs

serde-xml-rs

xml-rs based deserializer for Serde (compatible with 1.0)

borsh

Binary Object Representation Serializer for Hashing

bitcode

bitwise binary serializer

derive-where

Deriving with custom trait bounds

st-map

Runtime for a stack-alocated map

nunny

the definitive non-empty slice/array/vec library for Rust

serde-intermediate

Intermediate representation of Serde serialization

int-enum

A derive macro for conversion between integer and enum types

soa-rs

A Vec-like structure-of-arrays container

derive_setters

Rust macro to automatically generates setter methods for a struct's fields

deduplicating_array

A serde serialization strategy that uses PartialEq to reduce serialized size

libc-test

A test crate for the libc crate

cargo-derivefmt

Format derives alphabetically

serde_avro_fast

An idiomatic implementation of serde/avro (de)serialization

morphix

Observing and serializing mutations

statslicer

Guacamole provides a linearly-seekable random number generator

flat_error

Error wrapper to ensure Clone, Debug, and PartialEq

soapy

Structure-of-arrays derive macro

kmdparse

Parsing user's commands into arbitrary Rust types

spawned-rt

Spawned Runtime

fx-callback

A subscription based callback to inform subscribers about relevant data events within structs

xcfg-rs

configuration file parser for Rust

data-classes

Abbreviation of #[derive(xxx)]

sqlx_insert

Proc macro for generating insert statements for sqlx

handled

error handling library

rust-rel8

Rel8 but in rust

umili

Mutate and observe Rust data structures

typed-sled

Sled with types instead of bytes

meta_merge

Copy, deep-merge, and apply Rust attributes from one item to another

mdnt-groups-support

Support traits for the picus::group macro

protopuffer

Rust only protobuf implementation

cmdparse

Parsing user's commands into arbitrary Rust types

dropcatch

Drop detection library for Rust

serde_default

Generate a Default impl using serde attributes

lightyear_inputs_leafwing

IO primitives for the lightyear networking library

reltester

Automatically verify the correctness of [Partial]Eq/Ord implementations

nova

Macro to derive newtypes with support for serde and sqlx

useless_setter_maker

Macro for generating setter methods

treeerror

macros for generating trees of enums, as well as From implementations converting between them. Primarily intended for error handling.

always_equal

A wrapper for types that can't implement Eq

eventree

creating lossless syntax trees

typed-num

Typed number in Rust with serde and bincode support

lexi-matic

A Lexer Library

somedb

database for storing data

query_interface

Dynamically query a type-erased object for any trait implementation

reactive-signals

dx-first scope-based fine-grained reactive system

bin-tree

Building Binary Tree

karyon_eventemitter

A lightweight, asynchronous event emitter for Rust

resourcetrack

Basic tools for counting objects

ltv

Length Type Value - Reader / Writer

fieldmask

(de)serializing/applying fieldmask

raw_serde

A serialization library

quick-kv

A reliable key-value storage for modern software

fire-protobuf

Rust only protobuf implementation

spl-type-length-value

Solana Program Library Type-Length-Value Management

ops-derive2

Derive macros for implementing the std::ops traits

callable

closures implementing PartialEq and argument operations

entromatica

constructing, simulating and analyzing markov chains

convert_by_name

Derive From and Into for structs and enums based on field and variant names

freelist-rs

Free list for numeric values

dyn_std

Dynamic (object-safe) version of std traits

fsdb

filesystem database

algorithm_playground

Algorithms Playground: To learn and understand the working of different algorithms in Computer Science

opdater

Small trait based approch to struct updates

serde-keyvalue

Deserialize key=value parameters with serde

zhi_enum

derive macros to easily use enum

dyn_partial_eq

PartialEq macros for trait objects

small-num

Small crate used to create small numbers optimally

fuzzypath

Quick & dirty fuzzy path comparison

refid

Newtype enabling identity comparison (e.g. through pointer equality)

lexington

A very simple library for lexing / parsing

taker

Option-like taking for everyting with a default value

serfig

Layered configuration system built upon serde

retryiter

A wrapper lib on top of rust Iterator with added retry support

solarti-type-length-value

Solarti Program Library Type-Length-Value Management

async-prost

enum_const

enum const trait

derive-for

Macro for defining structs using the same derive procedural macros

trait-bound-typemap

create typemaps with additional trait restrictions and implementations

complex_algebra

supporting complex number algebra

statemachine-rs

A statemachine crate which have zero dependencies

new_york

Home of the dollar slice

qsort-rs

A quick sort algorithm that accepts any type and non-recursive approach

to_that

Declarative compile safe explict type conversion. Useful for chaining.

serde_enabled

A small wrapper for enabling/disabling sections in configuartion files easier with Serde

reglex

lexer generator using regex

dyn_derive

Inherit and derive object-unsafe traits for dynamic Rust

subset_eq

Procedural attribute macro to compare structs while ignoring specified fields while preserving full PartialEq

enum-utils

A set of useful proc macros for enums

dynex

Inherit and derive object-unsafe traits for dynamic Rust

lattices_macro

Procedural macros for the lattices crate

simple-builder

A procedural macro for creating a builder-pattern struct for any struct

sorted-list

SortedList data structure which allows mapping an Ord key to multiple distinct PartialEq values

tbg

implementing turn based games logic

partial_eq_dyn

Two traits to enable PartialEq for types with trait objects as fields. Best used with the derives in partial_eq_dyn_derive

state_machine

state machine

atlas-type-length-value

Atlas Program Library Type-Length-Value Management

kvp

types to store multiple fields where equality, ordering, and hashing are only implemented through one of the types

enum-utils-from-str

Code generation for mapping from strings to arbitrary values

bincode-sled

Sled with types instead of bytes. Powered by bincode-v2

uniquevec

A Vec-like datastructure which only contains unique entries. It is no_std and has optional serde support.

serde-xml-rust

Maintained fork of xml-rs based deserializer for Serde (compatible with 0.9+)

h2s_core

A core part of h2s

partial-context

Partial Context Types

float-derive

that allows deriving Eq and Hash for types that contain floating points

bytecoding

Derive macro for encoding and decoding instructions and operands as bytecode

meta_merge_core

Core logic for meta_merge

esde

serialize and deserialize library

autodefault

A proc macro that automatically inserts ..Default::default() into your struct literals

schmitttrigger

A generic SchmittTrigger implementation

sdi

Rust statically resolved dependency injection lib

EMUtil

This project will be contained with small utilities

derive-discriminant

A derive macro for enum discriminants

enum_array

A small crate adding a macro that creates a constant array containing all the items of the enum

scopes-macros

Macros for scopes-rs

skippable-partialeq

PartialEq, but you can ignore fields

kon_macros

Procedural macros for the Kon Engine

quantified

Specify the universe: None, Some, Excluding, and All

derive_aliases_proc_macro

detail of derive_aliases crate

pyderive-macros

Macros for pyderive crate

small_iter_fields

get an iterator, or get the length, or convert to a hashmap from an enum

clone-fields

Fields-wise types cloning

optional_struct_internal

Helper crate defining traits for the optional_struct crate

instrumented-stepanov

InstrumentedBase is collecting data about number of new, clone, drop, eq, partial cmp and cmp from Instrumented instates

from-num

Attribute macro #[from_num(...)]

derive_bounded

Builtin-macros workalike but with a way to specify bounds

plutus-parser

derive from_plutus and to_plutus on Rust types

chikatetsu

An(other) actor framework for Tokio

cargo-derivefmt-core

Core derivefmt functionality

nitroglycerin

High level dynamodb crate

natural-derive

Proc macros for naturally deriving basic trait impls for new types

insert-only-set

A procedural macro to generate insert-only sets from enums

same_enum

Generates From trait implementations for enums with the same unit variants

the-usual

derive the usual