seqlock

Adaptive Radix Tree in C++

C++ Concurrency Patterns

A blazingly fast™ single producer multiple consumer broadcast queue

High-performance AutoHotkey v2 library suite for real-time pipelines (Lock-Free IPC, SPSC, EMA, Telemetry, Watchdog, Raw Input...) with selftests and Gold stacks.

Ultra-low-latency SPMC/MPMC pub/sub using stamped ring buffers. Formally sound with atomic-slots feature. no_std, zero-alloc hot path. Apache-2.0.

A C++ implementation of the Sequence Lock

Splinter cohabitates inference and semantic governance in L3 cache and memory lanes, while simultaneously providing standardized POSIX-friendly tooling as building blocks on top of the provided library. Splinter is essentially a semantic "breadboard" that can be directly deployed at scale.

Ultra-low-latency, header-only concurrent cache for C++20 multi-platform and Windows Kernel (WDM/KMDF). Utilizes SeqLocks, tiered backoff, and NUMA-aware sharding to deliver nanosecond tail latencies with minimal (Linux) or no (Windows/Mac) dependencies.

A SeqLock (Sequence Lock) is a Reader-Writer Synchronisation Mechanism Used in Linux Kernel Development and Concurrent Programming

Experimental wait/lock-free primitives tuned for ultra-low-latency systems

Explore the intricate world of Kernel Sequential Locks through this repository, which provides a comprehensive understanding of seqlocks, their utility, working, and applications in Linux Kernel. Dive into the how-tos and subtle nuances with provided examples!

Lock seqlock

Lock-free primitives for FPU-less microcontrollers (SPSC/MPSC ring, seqlock, flag)

C++20 threaded OpenGL renderer built around three systems problems: thread-affine GL contexts, a lock-free input handoff, and precise frame pacing, all measured, not asserted. The cube is the demo, not the point.

A highly concurrent, lock-free hashmap in Go with wait-free reads, cooperative resizing, and cache-line optimized layouts.

Typed shared-memory contract research for coherent state across workers, AudioWorklets, and WebAssembly runtimes.

Low-latency limit-order-book engine in Rust. Four book structures benchmarked to the cache line, with the microarchitecture teardown of why the "optimal" one loses on real data.

Deterministic zero-allocation handoff primitives for no_std embedded Rust — ring buffers, latest-value snapshots, condition flags, saturating counters, and complete sample blocks. Bounded behaviour, measured cost, Loom-verified orderings.