-
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
-
tendril
Compact buffer/string type for zero-copy parsing
-
archery
Abstract over the atomicity of reference-counting pointers
-
by_address
Wrapper for comparing and hashing pointers by address
-
atomic_refcell
Threadsafe RefCell
-
guardian
owned mutex guards for refcounted mutexes
-
hipstr
string for Rust: zero-cost borrow and slicing, inline representation for small strings, (atomic) reference counting
-
weak-table
Weak hash maps and sets
-
rclite
small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs
-
memory-db
In-memory implementation of hash-db, useful for tests
-
rctree
A 'DOM-like' tree implemented using reference counting
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
jrsonnet-gcmodule
Cyclic garbage collection inspired by CPython's gc implementation
-
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
qcell
Statically-checked alternatives to RefCell and RwLock
-
rc-box
Known unique versions of Rc and Arc
-
relrc
Reference counted pointers, with relationships to other pointers
-
rc-borrow
Borrowed forms of Rc and Arc
-
rust-cc
A cycle collector for Rust programs
-
flexstr
A flexible, simple to use, immutable, clone-efficient
Stringreplacement for Rust -
refbox
A Box with weak references
-
harper-core
The language checker for developers
-
tracing-rc
Cycle-aware reference-counted pointers with a safe, simple api
-
pin-weak
Small wrapper around an equivalent of Pin<Weak<T>>
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
generic-container
Abstract over "containers" that hold a T, such as a T itself, Box<T>, or Arc<Mutex<T>>
-
pared
Projected reference counted pointers
-
static-rc
Compile-time reference counting
-
trc
A faster Arc
-
shared_vector
Reference counted vector data structure
-
malloc_size_of
A an allocator-agnostic crate for measuring the heap size of a value
-
hurry
Convenient macros for creating pointer types (Box, Rc, Arc, etc.)
-
compact-rc
Low-memory reference-counting pointers
-
rt-own
runtime ownership: owner, viewer and holder
-
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cowmeets anRc!) -
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
webgl-rc
WebGL wrapper with resources reference counting
-
thread_cell
Safe, Send + Sync access to !Send/!Sync data by isolating it on a dedicated thread and interacting with it through message passing. Perfect for Rc, RefCell, and other single-threaded types.
-
windres
Compiles Windows resource files (.rc) into a Rust program
-
libcanopy
Canopy is a lightweight tree-based data structure for Rust, optimized for reference management using Rc and Weak pointers
-
rc-vec
RcVec based on Rc and can be converted from Rc without allocation
-
bacon_rajan_cc
A reference counted type with cycle collection
-
deferred-cell
A single-assignment, weak reference wrapper for cyclic node graphs with late initialization
-
splitrc
Thread-Safe Split Reference Counts
-
cowstr
Copy-on-Write shared strings
-
slice-rc
A variety of reference-counted pointers with better support for slices than std::rc::Rc
-
arcslab
Slab, but with reference counted items
-
combarc
Copy-on-mutable-borrow reference counter type provider
-
pi_share
rc, arc, lock, atomic
-
cactusref
Cycle-aware reference counting smart pointer
-
stylo_malloc_size_of
An allocator-agnostic crate for measuring the heap size of a value
-
unique-rc
Unique owner Rc, like Box, can Send and DerefMut
-
weak-map
BTreeMap with weak references
-
genrc
refcounted pointer type that allows subobject pointers
-
esl01-minibytes
Shared reference-counted bytes with zero-copy slicing support
-
clone-behavior
Bound the semantic behavior and time complexity of cloning a value
-
hybrid-rc
Thread-safe hybrid reference counting pointers
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
abin
working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for small binaries;…
-
rc-hashmap
A HashMap with reference-counted key-value entries
-
our-string
Customizable shared strings with inlining
-
refpool
Efficient memory pool with reference counting
-
rc_gcode
GCode parser
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
sendable
Rc and Option equivalents that facilitate sending data between threads
-
fplist
An immutable, persistent, singly-linked list
-
kroos
Flexible smart pointer for ?Sized types with customizable reference counting
-
arc-bytes
A reference-counted byte buffer
-
wrc
A thread-safe weighted reference counting smart-pointer for Rust
-
dynec
An opinionated ECS-like framework
-
atomic-lend-cell
lending immutable references across threads with explicit owner-borrower semantics, offering both atomic reference counting and lightweight flag-based implementations
-
without-alloc
Replacements for
Box,Rc,Vec, .. withoutalloc -
rc-writer
A tiny implement for writing data to a reference counted instance
-
rco-cell
Wrapper for Rc<RefCell<Option<T>>> and its weak variant. Includes various utilties for common operations usually performed on such a datastructure.
-
mut-rc
Temporarily mutable
Rc<T>that decays intoRc<T> -
darc
Dynamically-atomic reference-counting pointers (proof of concept)
-
sapling-minibytes
Shared reference-counted bytes and str with zero-copy slicing support
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
inst_derive
Derive macro for tagged union enums implementing the Instantiable trait in safety-net
-
mappable-rc
mappable reference counted types
-
circ
Efficient referenced counted pointers for non-blocking concurrency
-
audio-garbage-collector
Wrapper on top of
basedropthat provides a drop-in GC API that’ll collect reference-counted values on a background thread -
rcu-clean
Smart pointers using RCU with Deref support
-
boar
Flexible clone on write smart pointers with Borrowed, Owned, Arc, Rc and Static variants. Like std's Cow without the ToOwned requirement and additional Rc, Arc or Static variants
-
buffet
Thread-local buffer pool for the
loonacrate -
gcmodule
Cyclic garbage collection inspired by CPython's gc implementation
-
refs
My vision of reference counting
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
strseq
A string sequence library for Rust
-
closure_attr
An attribute macro to simplify closure captures
-
snarc
Sendable Non-Atomically Reference Counted
-
parity-db
Key-value database for the blockchain
-
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
-
com-scrape-types
Support code for bindings generated with com-scrape
-
field33_rdftk_core_temporary_fork
core RDF data model; concrete implementations for Statements and Literals, along with a Resource type that provides a builder-like experience for models
-
snailcrypt
access api.snailcrypt.com
-
regc
A garbage collector that mixes Reference counting and mark sweeping
-
sti
STd Improved
-
pin-arc
Reference counting pointers without allocation using pinning
-
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.
-
parse_rc_ibus
parser for FlySky IBUS
-
mlsp
small library for smart pointers that use both thread local and global atomic counters
-
sylt-std
Standard library for the Sylt programming language
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
ref_arena
An arena of reference counted objects
-
memorydb
in-memory implementation of hashdb
-
arctree
A 'DOM-like' tree implemented using atomic reference counting
-
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.
-
rc-slice2
Reference-counted slices with easy subdivision
-
tupperware
Storage traits for your types
-
sycamore-state-core
sycamore-state core types and trait definitions
-
a_r_c_h_e_r_y
TEMPORARY CRATE
-
byte-slab
A statically allocated slab of bytes
-
arcstring
Atomically reference-counted thin string type with SSO
-
async_object
Async Object wrapper
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
collect_into_rc_slice
that let’s you collect an
Iterator<Item=T>into anRc<[T]>orArc<[T]>without needing to make 2 heap allocations -
type-handle
Regular and reference-counted type handles
-
rcuninit
Cyclic Rc without new_cyclic
-
sharedptr
Rust Sharedptr
-
refcount-interner
reference-counted interning library for strings, slices, and other data
-
shared_str
Shared str types providing more features over Rc<str> / Arc<str>
-
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
-
hashable_weak
A hashable weak pointer
-
rc_bump
An arena for heterogeneous types and without lifetimes
-
maprc
Rc and Arc alternatives that allow the smart pointer to refer to just a portion of a reference-counted allocation
-
refptr
Inherently reference counted structs
-
simple-rc-async
DryadSynth solver for string transformation programs
-
alias-ptr
(Mostly) safe manually-freed shared pointers in Rust
-
uni_rc_lock
trait which may represent either Rc<RefCell<T>> or Arc<RwLock<T>>
-
rccell
A convenient wrapper for Rc<RefCell<T>>
-
duals
dual-ownership referance cells
-
sylt-tokenizer
Tokenizer for the Sylt programming language
-
pi_pointer
Pointer, similar to arc and RC, but will allocate similar objects in a continuous space
-
archway
Rust traits for Rc and Arc interoperation
-
atomic-borrow
atomic reference counter
-
lazy_rc
implementations of Rc<T> and Arc<T> with lazy initialization
-
subrc
A tiny crate that exposes a
Rclike struct, which can be used to create a reference counted pointer to a subregion of aRc -
simple-digraph
Simplest reference-counting directed graph library
-
drc
add a new "Drc" smart pointer
-
hashable_rc
Hashable wrappers for reference countings
-
genref
Vale's generational references in Rust
-
toy_pool
Pool with reference-counted items
-
bytes-text
Reference-counted UTF-8 text
-
strong_rc
Reference counting smart pointer without weak count
-
crgc
Rust single thread GC based on reference counting + cycle removal. Inspired by QuickJS.
-
flexrc
A flexible/modular alternative to Rust Rc/Arc with unique hybrid capabilities
-
rc
A copy of std::rc that runs on stable Rust with weak references
-
sylt
programming language
-
gdnative-core
The Godot game engine's gdnative core bindings
-
rc_arena
An arena which yields reference counted pointers to the underlying objects
-
objt
Reference counted object helpers
-
dotr
Very simple dotfile manager
-
scell
A smart container for objects in recursive data structures
-
run-down
protection in rust
-
arc-buffer
A Clone-on-write reference-counter vector for Copy types
-
match_deref
Deref patterns in "match" for stable Rust. Now you can match through Rc, String, etc
-
match_box
boxand deref patterns in “match” for stable Rust. Now you can match throughBox,Rc, etc. -
extra_pointers
Box, Rc and Arc do not suffice? Take some extra
-
experimental-reactive
Experimental overheadless reactive programming framework
-
bark
reference counting pointer type
-
pin-rc
Combines reference counting semantics with a stable address guarantee
Try searching with DuckDuckGo.