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

archery

Abstract over the atomicity of reference-counting pointers

by_address

Wrapper for comparing and hashing pointers by address

mail-auth

DKIM, ARC, SPF and DMARC library for Rust

weak-table

Weak hash maps and sets

arcshift

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

kstring

Key String: optimized for map keys

rc-box

Known unique versions of Rc and Arc

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

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)

aws-sdk-arczonalshift

AWS SDK for AWS ARC - Zonal Shift

dupe

Marker for types which are cheap to clone

togo

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

readlock

A weird alternative to Arc<RwLock<T>>

readlock-tokio

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

aarc

An atomically updatable Arc for lock-free concurrency

basedrop

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

ra_ap_intern

Global Arc-based object interning infrastructure for rust-analyzer

rc-borrow

Borrowed forms of Rc and Arc

config_rw

配置文件读取与写入

hazarc

A wait-free AtomicArc optimized for read-intensive use cases

atomicow

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

serde_mosaic

Composable serialization and deserialization for Rust structs

pin-weak

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

offroad

2D offsetting for arc polylines/polygons

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.

PebbleVault

A high performance data storage solution written in rust

routingkit-cch

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

elysees

A fork of triomphe, now with more pointer trickery

rust-arc-gc

GCArc implementation for Rust

synchrony

that provides both sync and unsync versions of common synchronization primitives

configory

Batteries included application config management

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

aerosol

dependency injection for Rust

rushed

Simpler and faster shell commands

tarc

Transposable, type-erasable, and FFI-safe Arc

light_clone

Compile-time enforcement for O(1) clone operations

handle_trait

A trait for types that represent handles to shared resources

fob-graph

Fob graph - Pure graph data structures for module dependency graphs

take-once

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

rs-bean

A lightweight Rust library for bean management

gazebo

A collection of well-tested utilities

cowboy

Safe & convenient container for quick prototyping

cooked-waker

A safe interface for creating async Wakers

unarc-cli

Universal Archive Extractor - CLI tool for extracting various archive formats

synchronized-writer

A tiny implement for synchronously writing data

cloneable_errors

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

weak-map

BTreeMap with weak references

bumpref

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

rc-vec

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

revel_cell

arct-core

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

ankurah-signals

Ankurah Signals

compact-rc

Low-memory reference-counting pointers

hurry

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

simple_bt

minimal(-ish) behavior tree implementation

active_standby

A concurrency primitive for high concurrency reads

arct-ai

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

osui

A TUI library for advanced uis

obsidian-scheduler

scheduling tasks with both callback and event-based timers

kubus

Derive based kubernetes operator framework

imstr

Cheaply clonable and slicable immutable strings

arc_vec

Expensive but experimental project created for parallel execution

unique-rc

Unique owner Rc, like Box, can Send and DerefMut

noema

IOC and DI framework for Rust

hipool

RUST Memory Pool

rustigo

webserver inspired by the Go standard library's HTTPServer

arc-cell

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

arct-config

Configuration management for Arc Academy Terminal

yasi

String Interner

arct-telemetry

Privacy-first analytics and telemetry for Arc Academy Terminal

arcref

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

arct-tui

Terminal UI for Arc Academy Terminal - interactive shell learning interface

operi-runtime

Tool runtime for loading, discovery, policy enforcement, and execution

ez_tls

Super simple Tls api wrapper around rustls

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

easy_mutex

A cloneable mutex wrapper that simplifies everyday use

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!)

get_mut_drop_weak

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

dropcatch

Drop detection library for Rust

suika_server

A server library for the suika web stack

ej-io

Program management utilities for the EJ framework

lstring

Key String: optimized for map keys

speedy_refs

A collection of simple and fast and useful smart pointers

chord

Rust wrapper around d3-chord

tiptoe

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

HArcMut

mutable arc

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

mappable-rc

mappable reference counted types

comprehensive_dns

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

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…

game_inventory

An inventory system independant of item data

jss-pest

Arc Readable Configuration Parser via Pest

fobserver

A lightweight and straightforward HTTP server library written in Rust

blossom-arc

Arc Software CLI and library written in Rust for building the next generation app store for the Linux platform

arc-isle

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

ambient_cb

Defines helper types for callbacks wrapped in Arc that implement Debug

resourcetrack

Basic tools for counting objects

monome-rs

Talk to monome devices

light-cache

Async focused caching library

arc-writer

Arc writer

lmfu

Low Memory Footprint Utilities (String, HashMap, JSON)

next-web-websocket

Next Web Websocket

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)

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

weak-lists

Lists with weak references and concurrent iteration and modification

smash-arc

working with Smash Ultimate's data.arc files

rcell

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

larc

Lazy Arc/Weak pointers

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.

arc-swap-for-cow

Atomically swappable Arc

cura

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

llkv-btree

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

smol_buf

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

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.

smart

dynamically-dispatched smart pointers

hv-elastic

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

tarantula-shared

Share code for Tarantula CLI and UI

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

fenic

test concurrent code

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

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

alias-ptr

(Mostly) safe manually-freed shared pointers in Rust

rayon_croissant

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

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

next-web-core

Core library for the Next Web framework, providing essential web server and middleware abstractions

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

auto_new

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

reloadable-core

A generic reloadable state management core traits

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

moite_moite

Split a value in two owned parts

oyashio

spmc streams

mpc-macros

Arcium MPC Macros

finarc

Arc with finalizer called once last clone is dropped