### Top Candidates
- **arena-b**: Closest architectural match with bump arena, optional slab for fixed sizes, thread-local caches, and scoped reuse; study for core design and concurrency.
- **nexus-slab**: Strong on slab allocation with LIFO caching and low-latency churn; useful for fixed-size class and central pool ideas.
- **smmalloc**: General-purpose with thread-local slabs; inspect for per-thread caching and large alloc handling.
- **fixed-bump**: Fixed-chunk bump for latency-sensitive allocs; skim for arena reuse layers.
- **bumpalo**: Mature arena with collections; useful for API and benchmarking patterns.

| Name | Crates.io URL | Repository URL | One-sentence description | Category | Relevance score | Why relevant or not | Which part of Orthotope it may inform | Risks or mismatch notes | Suggested next action |
|------|---------------|----------------|---------------------------|----------|-----------------|---------------------|-------------------------------------|--------------------------|-----------------------|
| arena-b [^10](https://crates.io/crates/arena-b/0.1.0) [^62](https://crates.io/crates/arena-b) [^64](https://docs.rs/arena-b) | https://crates.io/crates/arena-b | https://quefep.uk [^63](https://quefep.uk) | High-performance bump arena with optional slab pooling, thread-local caches, and scoped allocations for allocation-heavy workloads. | direct architectural peer | 5 | Structural similarity in arena-backed bump with size-class slabs, per-thread hand-offs, and bulk reclaim; separates local reuse from shared growth; exposes direct API; includes benchmarks and prop tests. | allocator core, thread cache, central pool, API, testing, benchmarking | Optional thread-safety may introduce locks not ideal for high-throughput; evidence thin on large-object paths. | inspect deeply |
| nexus-slab [^2](https://crates.io/crates/nexus-slab) | https://crates.io/crates/nexus-slab | https://github.com/Abso1ut3Zer0/nexus [^3](https://github.com/Abso1ut3Zer0/nexus) | SLUB-style slab allocator for same-type objects with LIFO freelist caching and bounded/unbounded variants for low-latency churn. | partial peer | 4 | Matches fixed-size slab allocation with cache locality for small objects; distinguishes bounded central pools; O(1) alloc/free; benchmarks show speedup over Box; no thread-local but concurrent-friendly. | allocator core, central pool, thread cache (adapt LIFO), benchmarking | Single-type focus mismatches variable sizes; unsafe construction requires careful invariants; no large alloc handling visible. | inspect deeply |
| smmalloc [^73](https://crates.io/crates/smmalloc) | https://crates.io/crates/smmalloc | N/A | Simple, fast general-purpose allocator with per-thread slabs, separate large allocs, and minimal code for drop-in replacement. | partial peer | 4 | Uses thread-local slabs for small allocs with central coordination; handles large via direct mmap; relevant for high-throughput; benchmarks vs jemalloc/mimalloc. | thread cache, central pool, large allocation path, benchmarking | General-purpose may not align with arena-backed goals; lacks fixed classes; evidence thin on safety docs. | inspect deeply |
| fixed-bump [^4](https://crates.io/crates/fixed-bump) [^5](https://docs.rs/fixed-bump) [^6](https://github.com/taylordotfish/fixed-bump) | https://crates.io/crates/fixed-bump | https://github.com/taylordotfish/fixed-bump [^6](https://github.com/taylordotfish/fixed-bump) | Bump allocator using fixed-size chunks for non-amortized O(1) latency allocations in no_std environments. | partial peer | 3 | Arena-style bump with fixed chunks akin to size classes; supports reuse via reset; constant-time for small objects; allocator_api feature for direct use. | allocator core, arenas/reuse layers | No explicit thread caching or central pool; fails on oversized layouts without large path; no benchmarks in metadata. | skim only |
| bumpalo [^7](https://crates.io/crates/bumpalo) [^8](https://docs.rs/bumpalo) [^9](https://github.com/fitzgen/bumpalo) | https://crates.io/crates/bumpalo | https://github.com/fitzgen/bumpalo [^9](https://github.com/fitzgen/bumpalo) | Fast bump arena for phase-oriented allocations with collections, boxed support, and allocator_api integration. | useful adjacent reference | 3 | Core arena pattern for bulk small allocs with good cache locality; exposes direct API and std integration; mature tests/benchmarks; useful for reuse layers. | API, allocator core, arenas/reuse layers, testing, benchmarking | No fixed classes, thread caching, or large handling; exponential chunks amortize but not latency-optimized like Orthotope. | skim only |
| fastarena [^1](https://crates.io/crates/fastarena) [^60](https://github.com/themankindproject/fastarena-rs) [^61](https://docs.rs/fastarena) | https://crates.io/crates/fastarena | https://github.com/themankindproject/fastarena-rs [^60](https://github.com/themankindproject/fastarena-rs) | Zero-dependency bump arena with transactions, savepoints, and optional drop-tracking for request-scoped memory. | useful adjacent reference | 3 | Bump allocation with bulk reset for high-throughput; zero-copy refs and O(1) alloc; benchmarks vs bumpalo; relevant for arena reuse. | allocator core, arenas/reuse layers, API | Lacks size classes, caching, or large paths; single-threaded focus; no central coordination. | skim only |
| shared_arena [^65](https://docs.rs/shared_arena/latest/shared_arena/) [^79](https://github.com/sebastiencs/shared-arena) | https://crates.io/crates/shared_arena | https://github.com/sebastiencs/shared-arena [^79](https://github.com/sebastiencs/shared-arena) | Thread-safe memory pool with free-list pages and bitfields for fast same-size alloc/dealloc across threads. | useful adjacent reference | 3 | Central shared pool with atomic free-lists for coordination; 6-8x faster than system; distinguishes arena vs pool variants. | central pool, concurrency strategy | Fixed-size only, no thread-local or large handling; unsafe pointer derefs with full test coverage but thin safety docs. | skim only |
| fixed-size-allocator [^66](https://crates.io/crates/fixed-size-allocator) [^67](https://github.com/nic-obert/fixed-size-allocator) [^68](https://docs.rs/fixed-size-allocator/latest/fixed_size_allocator) | https://crates.io/crates/fixed-size-allocator | https://github.com/nic-obert/fixed-size-allocator [^67](https://github.com/nic-obert/fixed-size-allocator) | Simple fixed-size block allocator for pre-allocated chunks of uniform blocks in no_std. | partial peer | 2 | Direct fixed-size classes with bitmap-like tracking; O(1) for small uniform allocs; relevant for slab-like core. | allocator core, fixed-size-class | No variable sizes, caching, or large paths; basic, no benchmarks or advanced concurrency; evidence thin on invariants. | skim only |
| slaballoc [^72](https://docs.rs/slaballoc/latest/slaballoc/) | https://crates.io/crates/slaballoc | N/A | No_std thread-safe fixed-size slab for single-type objects using atomic bitmap in fixed memory block. | low relevance | 2 | Slab for fixed sizes with lockless alloc via atomics; relevant for central pool coordination. | central pool, slab allocators | Single-type only, no thread-local or large handling; bare-metal focus mismatches high-throughput targets. | ignore |
| polished_allocators [^69](https://crates.io/crates/polished_allocators) [^70](https://codeberg.org/ofluffydev/polished) | https://crates.io/crates/polished_allocators | https://codeberg.org/ofluffydev/polished [^70](https://codeberg.org/ofluffydev/polished) | Collection of allocators including bump, stack, and slab for OS/kernel use in no_std. | useful adjacent reference | 2 | Includes slab and bump variants; discusses GlobalAlloc impl and arena patterns; useful for embedded ideas. | allocator core, slab allocators, docs/safety | Kernel-oriented, low relevance to shared high-throughput; no specific caching or benchmarks visible. | ignore |
| refpool [^80](https://docs.rs/refpool/latest/refpool/) | https://crates.io/crates/refpool | N/A | Reusable pool for Box/Rc-like pointers with thread-local memory recycling for frequent small allocs. | useful adjacent reference | 2 | Thread-local pooling for reuse; outperforms system on small objects; relevant for caching strategy. | thread cache, API ergonomics | Rc-focused, not full allocator; no fixed classes or large paths; single-threaded. | ignore |
| flex_alloc [^71](https://docs.rs/flex-alloc/latest/flex_alloc) | https://crates.io/crates/flex-alloc | N/A | Flexible Box/Vec/Cow with optional fixed-buffer fallback and allocator_api2 support. | low relevance | 1 | Supports alloc flexibility for containers; useful narrow for API with fixed vs heap. | API | Not a core allocator; no classes/caching; more for collections than infrastructure. | ignore |
| bulk_allocator [^84](https://docs.rs/bulk_allocator/latest/bulk_allocator) | https://crates.io/crates/bulk_allocator | N/A | GlobalAlloc with bulk caching and deferred dealloc for reduced system calls. | low relevance | 1 | Central bulk pool for small allocs with cache; relevant for coordination. | central pool | No fixed classes or thread-local; general-purpose mismatch; thin evidence on safety. | ignore |