Lib.rs

arc-swap

Atomically swappable Arc

triomphe

A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)

stable_deref_trait

An unsafe marker trait for types like Box and Rc that dereference to a stable address even when moved, and hence can be used with libraries such as owning_ref and rental

arcstr

A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings

by_address

Wrapper for comparing and hashing pointers by address

archery

Abstract over the atomicity of reference-counting pointers

kstring

Key String: optimized for map keys

mail-auth

DKIM, ARC, SPF and DMARC library for Rust

arcshift

Replacement for std::sync::Arc<T> that supports updating the value, with some caveats

weak-table

Weak hash maps and sets

unarc-rs

Universal archive extraction & decompression library for retro + modern formats (7z, ZIP, RAR, LHA/LZH, TAR, ARJ, ARC/PAK, ZOO, HA, UC2, SQ/SQ2, SQZ, HYP, gz, bz2, Z)

rclite

small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs

aws-sdk-route53recoverycluster

AWS SDK for Route53 Recovery Cluster

algorithm

about algorithm data structure, now has ttl with lru/lru-k/lfu/arc and slab/rbtree/roaring_bitmap/timer_wheelss, 关于算法常用的数据结构

anybytes

A small library abstracting over bytes owning types in an extensible way

dupe

Marker for types which are cheap to clone

aws-sdk-arczonalshift

AWS SDK for AWS ARC - Zonal Shift

rc-box

Known unique versions of Rc and Arc

togo

2D geometry, providing geometric algorithms for intersection/distance between circular arcs/line segments

atomicow

A Cow-like data structure where owned data is stored inside an Arc

aarc

An atomically updatable Arc for lock-free concurrency

readlock-tokio

A weird alternative to Arc<RwLock<T>>, using tokio's RwLock

readlock

A weird alternative to Arc<RwLock<T>>

ra_ap_intern

Global Arc-based object interning infrastructure for rust-analyzer

basedrop

Memory management tools for real-time audio and other latency-critical scenarios

rc-borrow

Borrowed forms of Rc and Arc

configory

Batteries included application config management

pin-weak

Small wrapper around an equivalent of Pin<Weak<T>>

offroad

2D offsetting for arc polylines/polygons

PebbleVault

A high performance data storage solution written in rust

elysees

A fork of triomphe, now with more pointer trickery

suika

web stack for building web applications

warcrwlock

in Rust that provides an attribute macro for structs and traits. Rewrite code using under the hood asynchronous reference (Arc) and asynchronous writing and read(RWlock) control elements.

routingkit-cch

Rust bindings for RoutingKit's Customizable Contraction Hierarchies (CCH)

rushed

Simpler and faster shell commands

rust-arc-gc

GCArc implementation for Rust

aerosol

dependency injection for Rust

unarc-cli

Universal Archive Extractor - CLI tool for extracting various archive formats

tarc

Transposable, type-erasable, and FFI-safe Arc

cachelito

Procedural macro for automatic function caching with LRU/FIFO/LFU/ARC/Random/TLRU/W-TinyLFU policies, expiration, limits, and thread-local or global scope

take-once

A thread-safe container for one-time storage and one-time consumption of a value

fob-graph

Fob graph - Pure graph data structures for module dependency graphs

cowboy

Safe & convenient container for quick prototyping

handle_trait

A trait for types that represent handles to shared resources

cooked-waker

A safe interface for creating async Wakers

bumpref

Explicit .bump() method for Arc and Rc that signals cheap refcount cloning

gazebo

A collection of well-tested utilities

cloneable_errors

similar to anyhow, that allows the errors to be cloned, shared, cached and even sent over the network

rc-vec

RcVec based on Rc and can be converted from Rc without allocation

simple_bt

minimal(-ish) behavior tree implementation

compact-rc

Low-memory reference-counting pointers

revel_cell

synchronized-writer

A tiny implement for synchronously writing data

hurry

Convenient macros for creating pointer types (Box, Rc, Arc, etc.)

active_standby

A concurrency primitive for high concurrency reads

ankurah-signals

Ankurah Signals

arc_vec

Expensive but experimental project created for parallel execution

arct-core

Core library for Arc Academy Terminal - command analysis and learning engine

theory_core

Neuro-symbolic reasoning core with SMT solver integration

rustigo

webserver inspired by the Go standard library's HTTPServer

imstr

Cheaply clonable and slicable immutable strings

arct-ai

AI integration for Arc Academy Terminal - OpenAI, Anthropic, and local LLM support

unique-rc

Unique owner Rc, like Box, can Send and DerefMut

obsidian-scheduler

scheduling tasks with both callback and event-based timers

hipool

RUST Memory Pool

kubus

Derive based kubernetes operator framework

weak-map

BTreeMap with weak references

easy_mutex

A cloneable mutex wrapper that simplifies everyday use

arcref

For when you need a pointer and don't care if it's &'static T or Arc<T>

sentry-options-validation

Schema validation library and CLI for sentry-options

arc-cell

Helper for a simple Cell-like object containing Arc/Weak

yasi

String Interner

bound

Wrap lock guards and other structs along with the locks or other data they are derived by shared reference from, in a struct you can pass around and store anywhere

arct-config

Configuration management for Arc Academy Terminal

get_mut_drop_weak

A function to safely get a mutable reference to an Arc and dissociate any weak references

arct-tui

Terminal UI for Arc Academy Terminal - interactive shell learning interface

arct-telemetry

Privacy-first analytics and telemetry for Arc Academy Terminal

xarray

version of the XArray with copy-on-write capabilities

backdrop_arc

Arc which will drop its large or complex contents in the background with Backdrop! (later, on another thread, or both! Fully customizable! Tokio supported!)

dropcatch

Drop detection library for Rust

suika_server

A server library for the suika web stack

lstring

Key String: optimized for map keys

ej-io

Program management utilities for the EJ framework

speedy_refs

A collection of simple and fast and useful smart pointers

HArcMut

mutable arc

chord

Rust wrapper around d3-chord

tiptoe

An easy-to-support intrusively reference-counting smart pointer

coi-actix-web

integration support between coi and actix-web

libarc2

Low-level interface library for ArC TWO™

rcu-clean

Smart pointers using RCU with Deref support

comprehensive_dns

A DNS resolver for https://crates.io/crates/comprehensive

tarantula-shared

Share code for Tarantula CLI and UI

coi

Dependency Injection library

pubsub-rs

powerful publish-subscribe (pubsub) system that allows multiple subscribers to receive messages published to specific topics. It is designed to be thread-safe, async-friendly, memory-efficient…

mappable-rc

mappable reference counted types

jss-pest

Arc Readable Configuration Parser via Pest

game_inventory

An inventory system independant of item data

fobserver

A lightweight and straightforward HTTP server library written in Rust

ambient_cb

Defines helper types for callbacks wrapped in Arc that implement Debug

arc-isle

The Interface Specification Language for the Arc project: design and implementation

light-cache

Async focused caching library

monome-rs

Talk to monome devices

arc-writer

Arc writer

lmfu

Low Memory Footprint Utilities (String, HashMap, JSON)

arcu

An Rcu implementation using an Arc to keep the read critical section short and handle cleanup

ptnet-elementary

ptnet-core for Elementary nets (EN)

resourcetrack

Basic tools for counting objects

next-web-websocket

Next Web Websocket

basic-oop

OOP for Rust

libsmallworld

behind the "smallworld" binary crate

asc

Atomic Strong Count

arc-handle

Proc macro for generating Arc-based handle wrappers for traits

llkv-btree

Generic, paged B+Tree with batch-only pager I/O for the LLKV toolset

smash-arc

working with Smash Ultimate's data.arc files

weak-lists

Lists with weak references and concurrent iteration and modification

rcell

A Cell which can hold either an Arc or an Weak smartpointer or be empty

larc

Lazy Arc/Weak pointers

entromatica

constructing, simulating and analyzing markov chains

arc-atomic

atomic pointer to an Arc

arcerror

thin wrappers around Arc<T> and Rc<T> where T: Error. Impls Error for both of these types. No unsafe, no dependencies.

smol_buf

small-string optimized string / buffer type with O(1) clone

arc-swap-for-cow

Atomically swappable Arc

cura

arc-lock-system that should clean up the code a lot

ownref

Provide the smart pointer type that bundles the data with its owner

counting-pointer

structs of reference counting pointers. The perforance is better than 'std::rc::Rc' and than 'std::sync::Arc' by counting only the strong references but not weak the references.

hv-elastic

Safe and almost-safe abstractions for lengthening lifetimes and 'static “loaning” of non-'static types

smart

dynamically-dispatched smart pointers

a_r_c_h_e_r_y

TEMPORARY CRATE

workerpool-rs

workerpool for rust

hv-cell

A no-std port of the atomic_refcell crate with additional Arc-centric functionality

yukon

trait for the ability to cheaply duplicate an object

clickhouse-srv

Bindings for emulating a ClickHouse server

node-to-arc-centric-dbg

Convert node-centric de Bruijn graphs as output by BCALM2 into arc-centric de Bruijn graphs as edge lists

async_object

Async Object wrapper

arc-cow

ArcCow is a Rust smart pointer that combines the best features of Cow (clone-on-write) and Arc (atomic reference counting) to provide efficient, flexible data handling

arcflash

Arc flash calculations according to IEEE 1584

pour

Optionally consed radix tries for fast set operations

collect_into_rc_slice

that let’s you collect an Iterator<Item=T> into an Rc<[T]> or Arc<[T]> without needing to make 2 heap allocations

fenic

test concurrent code

callback_cell

Like an Atomic<Option<Box<FnOnce()>>>

atomic_sibling_counter

A shared counter that allows parallel threads/tasks to check how many siblings they have. The counter is atomic and threads/tasks are not synchronized or coupled in any way.

wobbly

wobbly-owned reference counting pointers that mostly behave like Weak but can also keep a value alive

re-init-rc

Wrappers for Rc and Arc weak pointers for auto re-initialization of inner value on access when it is already dropped

arbalest

Like Arc<T> but where weak references don't forbid mutable access

refptr

Inherently reference counted structs

endgame_egui

integrating endgame with the egui GUI library

rayon_croissant

<lqd> bikeshedding the name: something that is mapped folded and collected, a 🥐

alias-ptr

(Mostly) safe manually-freed shared pointers in Rust

tark

An Arc with a thread-local strong/weak count

serde-intern

A Serde addon that allows interning of strings and byte sequences behind Arcs during deserialization

uni_rc_lock

trait which may represent either Rc<RefCell<T>> or Arc<RwLock<T>>

quinine

Atomic monotonic containers (Mono{Box,Arc})

fallacy-arc

fallible Arc

verilog-arc

proc macro based code generation backend for OpenVAF

shared-type

Shared type alias and several traits to simplify working with Arc<Mutex<T>>

arcmut

Introduce ArcMut, utility for FFI

arc_new_cyclic_n

Functions like Arc::new_cyclic but with arities greater than 1

arc-ext

Extensions for Arc<T> such as field projection

io-arc

Proof of concept Arc with IO trait delegation

re0-pest

Arc Readable Configuration Parser via Pest

reloadable-state

A generic reloadable shared state

archway

Rust traits for Rc and Arc interoperation

tinypointers

Pointer implementations that take 8 or 16 bits

arcell

Arc obtains internal variability

arc-trait

Automagically implement any trait for Arc<T>

extra_atomics

Abstraction over atomic ptr. Such as AtomicBox and AtomicArc.

limit-alloc

A custom allocator that allows to limit the available memory

cancel

co-operative cancellation

reloadable-core

A generic reloadable state management core traits

auto_new

basic macro for removing the need to write new(...) on structs

provenant

A version of Arc that can free memory while weak pointers exist by probabilistically tracking provenace

arc-pest

Arc Readable Configuration Parser via Pest

with_lock_auto

easily and safely access arc-mutexes without

oyashio

spmc streams

moite_moite

Split a value in two owned parts

finarc

Arc with finalizer called once last clone is dropped