Skip to content
CAI
Software that uses CAICheck a score

crossbeam-rs/crossbeam

73.4

Strong · 14 November 2026

25k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add sanitize example to demonstrate thread-safe atomic operations

A new example file, sanitize.rs, has been added to the crossbeam-epoch examples directory. This example demonstrates the usage of crossbeam-epoch's atomic types and garbage collection by spawning multiple threads that concurrently update and read shared atomic values using fastrand for randomization. It serves as a practical reference for implementing thread-safe concurrent data structures with epoch-based reclamation.

crossbeam-epoch/examples · high confidence

Added benchmark suites and example for crossbeam-skiplist

Added new benchmark files (btree.rs, hash.rs, skiplist.rs, skipmap.rs) to compare the performance of crossbeam-skiplist's SkipList and SkipMap against standard library collections (BTreeMap, HashMap) for operations like insert, iter, rev\_iter, lookup, and insert\_remove. Also added a simple example file (simple.rs) demonstrating basic usage, though it is currently commented out.

crossbeam-skiplist/benches · high confidence

Automated release publishing script

A new shell script (tools/publish.sh) has been added to automate the release process for crates. Users can now publish a new release by running the script with a crate name and version; the script validates the version format, ensures the working directory is clean, checks that the tag does not already exist, verifies the current branch is 'main', creates the git tag, publishes the crate using the stable Rust toolchain, and pushes the tag to the remote repository.

tools · high confidence

Initial release of crossbeam crate

This entry introduces the crossbeam crate as a new dependency for concurrent programming in Rust. It re-exports key components from its sub-crates, including \crossbeam-utils\ (for \AtomicCell\, \CachePadded\, and \Backoff\), \crossbeam-channel\ (for MPMC channels and select), \crossbeam-deque\ (for work-stealing deques), \crossbeam-epoch\ (for epoch-based garbage collection), and \crossbeam-queue\ (for bounded and unbounded queues). The crate supports \no\_std\ environments and enables \std\ features conditionally.

src · high confidence

Initial release of crossbeam-skiplist

The crossbeam-skiplist crate is introduced, providing concurrent, thread-safe \SkipMap\ and \SkipSet\ data structures with an API similar to \BTreeMap\ and \BTreeSet\. This release establishes the project's foundation, including the initial implementation, dual MIT/Apache-2.0 licensing, and documentation. It sets the minimum supported Rust version (MSRV) to 1.74 and supports \no\_std\ environments when the \alloc\ feature is enabled.

crossbeam-skiplist · high confidence

Introduce custom comparators for SkipMap and SkipSet

Users can now provide a custom comparator to \SkipMap\ and \SkipSet\ instead of relying on the default \Ord\ implementation for keys. This is achieved by passing a type implementing the new \Comparator\ and \Equivalator\ traits (e.g., via \with\_comparator\). This allows for flexible key ordering and equality checks, such as case-insensitive string comparison or runtime-configurable logic, decoupling the data structures from the standard library's \Borrow\ and \Ord\ constraints.

crossbeam-skiplist/src · high confidence

Introduction of crossbeam-queue crate with ArrayQueue and SegQueue

The crossbeam-queue crate is now available, providing two concurrent queue implementations: ArrayQueue, a bounded multi-producer multi-consumer queue that allocates a fixed-capacity buffer for faster performance, and SegQueue, an unbounded multi-producer multi-consumer queue that dynamically allocates segments as needed. Both queues support no\_std environments (with the alloc feature) and implement UnwindSafe and RefUnwindSafe traits.

crossbeam-queue/src · high confidence

Introduction of internal lock-free synchronization primitives

The \crossbeam-epoch/src/sync\ module now includes internal implementations of a lock-free intrusive linked list (\list.rs\) and a Michael-Scott lock-free queue (\queue.rs\). These primitives provide the foundational concurrency structures used by the epoch-based reclamation system, replacing previous ad-hoc or external synchronization mechanisms with these specific, audited implementations.

crossbeam-epoch/src/sync · high confidence

New Backoff primitive and allocation helpers in crossbeam-utils

The \crossbeam-utils\ crate now includes a \Backoff\ type for performing exponential backoff in spin loops, helping to reduce contention and improve performance in lock-free code. Additionally, an internal \alloc\_helper\ module has been added to provide safer allocation primitives, and \CachePadded\ has been updated with architecture-specific alignment constants (e.g., 128-byte on x86-64/aarch64) to optimize cache line usage.

crossbeam-utils/src · high confidence

New and updated channel examples

The examples directory now includes a new asynchronous Fibonacci generator (fibonacci.rs) and a stopwatch that handles Ctrl+C signals (stopwatch.rs). The existing CSP-style matching example has been renamed to matching.rs, updated to use modern Rust idioms (crossbeam\_utils::thread::scope instead of crossbeam::scope), and improved to correctly handle pending send operations via try\_recv.

crossbeam-channel/examples · high confidence

New thread synchronization primitives: Parker, ShardedLock, and WaitGroup

The \crossbeam-utils\ crate now exposes a new \sync\ module containing three synchronization primitives. \Parker\ provides a thread parking mechanism with \park\, \park\_timeout\, and \park\_deadline\ methods, allowing threads to wait for signals or timeouts. \ShardedLock\ offers a sharded reader-writer lock that improves read scalability by splitting the lock into multiple shards, while \WaitGroup\ enables threads to synchronize the start or end of computations by tracking reference counts. These types are implemented from scratch within the crate, including a custom \OnceLock\ for lazy initialization, and are available for use in both \std\ and \no\_std\ environments.

crossbeam-utils/src/sync · high confidence

Project initialization and tooling configuration

The repository has been initialized with the Crossbeam project, including the main crate and its subcrates (crossbeam-channel, crossbeam-deque, crossbeam-epoch, crossbeam-queue, crossbeam-utils). This change introduces standard project configuration files: a Clippy configuration that disallows unsafe \transmute\_copy\ and raw allocation functions in favor of safer helpers, a Rustfmt configuration enforcing specific import granularity and style editions, a ShellCheck configuration for shell scripts, and a Taplo configuration for TOML formatting. It also adds a comprehensive CHANGELOG documenting the project's history from v0.1 to v0.8.5, updates the README with current usage instructions and compatibility notes (Rust 1.74+), and establishes the dual MIT/Apache-2.0 licensing structure.

(repo-wide) · high confidence

Work-stealing deque implementation with FIFO/LIFO workers and global injector

The \crossbeam-deque\ crate now provides a concurrent work-stealing deque implementation suitable for task schedulers. It introduces an \Injector\ for global task insertion, \Worker\ queues supporting both FIFO and LIFO insertion policies, and \Stealer\ handles for stealing tasks from other workers. The implementation optimizes performance by using 64-bit atomic indices where available and limits batch steal sizes to 32 tasks to balance overhead and efficiency.

crossbeam-deque/src · high confidence

Behavioural changes

Add build script for ThreadSanitizer detection and update documentation

The crossbeam-deque crate now includes a build script that detects ThreadSanitizer usage (via the \CARGO\_CFG\_SANITIZE\ environment variable or specific target triples) to enable optimized compatibility, alongside updated README and CHANGELOG files reflecting the current MSRV of 1.74 and recent performance and stability improvements.

crossbeam-deque · high confidence

AtomicCell now uses global sequence locks for fallback synchronization

The \AtomicCell\ implementation in \crossbeam-utils\ has been refactored to use a stamped sequence lock (\SeqLock\ or \SeqLockWide\ for narrow architectures) as the fallback mechanism when native atomic instructions are unavailable. This change replaces the previous global lock approach, ensuring that aborted writes do not incorrectly update the sequence stamp, which prevents potential data races and improves correctness for non-lock-free types. Additionally, the module now exposes the \AtomicConsume\ trait, allowing efficient 'consume' ordering loads on architectures that support it (like ARM/AArch64) while falling back to 'acquire' ordering elsewhere.

crossbeam-utils/src/atomic · high confidence

Benchmark suite modernization and expansion

The benchmark suite has been updated to use Rust 2018 idioms, replacing the legacy \crossbeam::scope\ API with the modern \crossbeam::scope\ that returns a result, and standardizing message handling via a shared \message\ module. The suite now includes new benchmarks for the \flume\ and \futures-channel\ libraries, alongside existing ones for \crossbeam-channel\, \mpsc\, \lockfree\, \segqueue\, and others. The Go benchmark has been fixed to properly select over channels during concurrent puts, and the Python plotting script has been updated to support Python 3 and Matplotlib, replacing the previous hardcoded results with a dynamic \plot.py\ generator.

crossbeam-channel/benchmarks · high confidence

Crossbeam Channel 0.5.17 release notes and license files added

This change introduces the CHANGELOG.md for crossbeam-channel version 0.5.17, documenting fixes for undefined behavior in bounded channels, behavior inconsistencies in the \at()\ method, overflow handling during channel initialization, and the adoption of 64-bit indices on 32-bit platforms where supported. It also updates the MSRV policy to support a 1-year window. Additionally, the repository now includes explicit LICENSE-APACHE, LICENSE-MIT, and LICENSE-THIRD-PARTY files to clarify the dual MIT/Apache-2.0 licensing and third-party attribution.

crossbeam-channel · high confidence

Crossbeam-channel refactored into a modular, no\_std-compatible library

The crossbeam-channel crate has been restructured into a modular architecture with dedicated source files for channels, selection, and utilities, while adopting Rust 2018/2021 idioms and no\_std compatibility. This change introduces a non-poison Mutex wrapper for safer synchronization, replaces raw pointer arithmetic with \MaybeUninit\ and \NonNull\ for safer memory handling, and adds new error types (\TryReadyError\, \ReadyTimeoutError\) with \Display\ and \Error\ implementations. Users benefit from improved reliability through better panic safety, more precise error reporting, and the ability to use the library in environments without the standard library, alongside performance optimizations in channel disconnection and selection logic.

crossbeam-channel/src · high confidence

Improved ThreadSanitizer compatibility and updated MSRV policy

The crossbeam-epoch crate now includes better compatibility with ThreadSanitizer by detecting sanitization builds via the build script and adjusting internal behavior accordingly. Additionally, the minimum supported Rust version (MSRV) policy has been updated to support releases going back at least one year, aligning with rayon's MSRV policy, and the current MSRV is set to Rust 1.74.

crossbeam-epoch · high confidence

New CI scripts for comprehensive testing and sanitization

The CI infrastructure now includes dedicated shell scripts to run a broader suite of checks: \test.sh\ for standard and cross-compilation tests, \careful.sh\ for undefined behavior detection with \cargo-careful\, \miri.sh\ for Miri-based memory safety verification, \san.sh\ for Address, Memory, and Thread Sanitizers, \check-features.sh\ for exhaustive feature-combination validation (including MSRV and \no\_std\ targets), \dependencies.sh\ for dependency tree analysis, and \crossbeam-epoch-loom.sh\ for loom-based concurrency testing.

ci · high confidence

Refactored channel internals into modular flavor implementations

The internal channel implementation has been restructured into distinct, modular 'flavors' located in the \flavors\ module. This change introduces specific implementations for bounded channels (\array\), unbounded channels (\list\), and specialized channels for timed delivery (\at\), periodic ticks (\tick\), zero-capacity rendezvous (\zero\), and non-delivering channels (\never\). This modularization isolates the logic for each channel type, improving code organization and maintainability while preserving the existing public API behavior.

crossbeam-channel/src/flavors · high confidence

crossbeam-epoch restructured into new modules with improved atomic APIs

The crossbeam-epoch crate has been reorganized into distinct source files (atomic, collector, deferred, epoch, guard, internal) to improve code structure and maintainability. The atomic module now provides CompareExchangeValue and CompareExchangeError types that return both old and new values on compare-and-swap operations, replacing the deprecated compare\_and\_set API. The default module uses std::sync::OnceLock for lazy initialization of the global collector, and the deferred module supports unsized types through a new Data structure that can hold functions inline or on the heap. The epoch module now conditionally uses AtomicU64 on platforms that support it for better performance.

crossbeam-epoch/src · high confidence

crossbeam-queue v0.3.14 release notes and license files added

This change introduces the CHANGELOG.md for crossbeam-queue v0.3.14, documenting that the library now uses 64-bit indices on 32-bit platforms when 64-bit atomics are available and updates the Minimum Supported Rust Version (MSRV) policy to support releases for one year instead of six. It also adds the full text of the Apache-2.0 and MIT license files, reflecting the crate's dual licensing model.

crossbeam-queue · high confidence

crossbeam-utils v0.8.23 release notes and sanitizer support improvements

This change introduces the changelog for crossbeam-utils v0.8.23, which fixes a safety violation when ShardedLockWriteGuard is leaked and improves compatibility with ThreadSanitizer. It also updates the MSRV policy to support a 1-year window. The diff includes the full historical changelog, license files, and a build script that detects thread sanitizers to force fallback implementations for AtomicCell, ensuring correctness under sanitization.

crossbeam-utils · high confidence

Test coverage

Add microbenchmarks for crossbeam-channel operations; Added benchmark suite for epoch operations; Added benchmarks for AtomicCell operations; Added comprehensive test coverage for deque primitives; Added comprehensive test suite for SkipList, SkipMap, and SkipSet; Added comprehensive test suites for crossbeam-utils components; Added loom-based concurrency tests for epoch primitives and Treiber stack; Added test coverage for ArrayQueue and SegQueue; Added tests for subcrate re-exports; Comprehensive test suite for crossbeam-channel channel flavors and selection mechanisms.

Dependencies

Crossbeam workspace updated to 0.8.5 with Rust 2021 edition and MSRV 1.74

The crossbeam workspace has been updated to version 0.8.5, migrating all subcrates (crossbeam-channel, crossbeam-deque, crossbeam-epoch, crossbeam-queue, crossbeam-skiplist, crossbeam-utils) to the Rust 2021 edition. The minimum supported Rust version (MSRV) for most crates is now 1.74, with crossbeam-queue requiring 1.60 and crossbeam-utils 1.56. Dependencies have been bumped to crossbeam-channel 0.5.17, crossbeam-deque 0.8.8, crossbeam-epoch 0.9.21, crossbeam-queue 0.3.14, crossbeam-skiplist 0.1.3, and crossbeam-utils 0.8.23. The workspace now uses resolver 2 and enforces strict linting via workspace-level lints configuration.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 74 → 73 (-0.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 92 → 84 (-7.3)
  • Architecture 99 → 99 (+0.0)
  • Maturity 61 → 61 (+0.1)
  • Readiness 87 → 88 (+0.6)
  • Security 81 → 81 (+0.0)
  • Performance 85 → 85 (+0.0)

Resolved (28)

  • Duplicated block (10 lines × 2) (crossbeam-deque/src/deque.rs)
  • Duplicated block (10 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (11 lines × 3) (crossbeam-deque/src/deque.rs)
  • Duplicated block (11 lines × 4) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (12 lines × 2) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (12–13 lines × 3) (crossbeam-deque/src/deque.rs)
  • Duplicated block (13 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (13 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (14 lines × 2) (crossbeam-channel/src/flavors/array.rs)
  • Duplicated block (14 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (15 lines × 2) (crossbeam-epoch/src/sync/queue.rs)
  • Duplicated block (17 lines × 2) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (18 lines × 2) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (19 lines × 2) (crossbeam-deque/src/deque.rs)
  • Duplicated block (19 lines × 3) (crossbeam-deque/src/deque.rs)
  • Duplicated block (20 lines × 2) (crossbeam-channel/src/flavors/array.rs)
  • Duplicated block (23 lines × 2) (crossbeam-deque/src/deque.rs)
  • Duplicated block (43–44 lines × 2) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (5 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (60–61 lines × 2) (crossbeam-deque/src/deque.rs)
  • …and 8 more

New (79)

  • Duplicated block (10 lines × 2) (crossbeam-channel/src/flavors/zero.rs)
  • Duplicated block (10 lines × 2) (crossbeam-deque/src/deque.rs)
  • Duplicated block (10 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (11 lines × 3) (crossbeam-deque/src/deque.rs)
  • Duplicated block (12 lines × 2) (crossbeam-deque/src/deque.rs)
  • Duplicated block (12–13 lines × 3) (crossbeam-deque/src/deque.rs)
  • Duplicated block (13 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (14 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (15 lines × 2) (crossbeam-channel/src/select.rs)
  • Duplicated block (15 lines × 2) (crossbeam-epoch/src/sync/queue.rs)
  • Duplicated block (15 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (16 lines × 2) (crossbeam-deque/src/deque.rs)
  • Duplicated block (17 lines × 2) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (18 lines × 2) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (19 lines × 2) (crossbeam-deque/src/deque.rs)
  • Duplicated block (19 lines × 3) (crossbeam-deque/src/deque.rs)
  • Duplicated block (23 lines × 2) (crossbeam-deque/src/deque.rs)
  • Duplicated block (42–43 lines × 2) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (5 lines × 3) (crossbeam-channel/src/flavors/list.rs)
  • Duplicated block (60–61 lines × 2) (crossbeam-deque/src/deque.rs)
  • …and 59 more

Changes since last survey

  • 4 commits — 2 feature/other, 2 fixes

By area

  • crossbeam-utils/src — 2 commits
  • .github/workflows — 1 commit
  • crossbeam-channel/src — 1 commit

Notable commits

  • fix: ShardedLock: Fix Debug implementation for ShardedLock{Read,Write}Guard (#1350)
  • fix: utils: Fix ShardedLock::write documentation copied from read (#1292)
  • change: Bump taiki-e/install-action from 2.87.14 to 2.87.29 (#1354)
  • change: select_macro: Stop erasing Sender/Receiver lifetime to please non-NLL borrowck (#1353)

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

crossbeam-rs/crossbeam was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit a28f40fdddb70bea8e5faf0efad9af0be4b9dbea — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.