Lib.rs

atomic

Generic Atomic<T> wrapper type

try-lock

A lightweight atomic lock

lock_api

Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.

fs-lock

Locked files that can be used like normal File

fslock

files as locks

rslock

distributed locking mechanism built on top of Async Redis

hk

managing git hooks

eugene

Careful with That Lock, Eugene

nils-git-lock

CLI crate for nils-git-lock in the nils-cli workspace

futures-locks

Futures-aware lock primitives

redisson

A Redis-based distributed synchronization and data structures library for Rust

env-lock

Set and lock environment variables for tests

kube-leader-election

Leader election implementations for Kubernetes workloads

xutex

an extremely fast async mutex with alternative sync API

vmprotect

Unofficial VMProtect SDK for Rust

memsafe

A Secure cross-platform Rust library for securely wrapping data in memory

wit-deps-cli

WIT dependency manager

oml-storage

A very simple wrapper to handle locked storage of items

wit-deps

WIT dependency management

range-lock

Range lock for std::vec::Vec

whatwg_streams

whatwg_streams for rust

safe-lock

A lock struct with a const fn constructor and no unsafe - ARCHIVED

lockmap

A high-performance, thread-safe HashMap implementation for Rust that provides fine-grained locking at the key level

distributed-lock

Distributed locks for Rust with multiple backend support (PostgreSQL, Redis, MySQL, MongoDB, file system)

locked-tripwire

Prevent cargo installs without --locked

cross-locks

FIFO-fair global locks that work identically on native, browser-WASM and head-less WASM

bpf

Attach BPF filters

file-locker

File locking via POSIX advisory record locks

interlock

Readers-writer locks designed for locking intervals

k-lock

A fast mutex for short critical sections

soundstoic

macOS menu bar agent that locks the default input device using Core Audio HAL listeners

terminus-store

a triple store library

lock-build-bin

A bin for checking install with lock

distributed-lock-redis

Redis backend for distributed locks with RedLock algorithm support

pgmanager

Provide locked access to test databases

squawk-linter

Linter for Postgres migrations & SQL

kimojio

A thread-per-core Linux io_uring async runtime optimized for latency

libbrat-worktree

Git worktree management for Brat polecat sessions

tlq

Tiny Little Queue

lockfile

Create lockfiles that remove themselves when they are dropped

locksmith

Extract Postgres locks from a given SQL statement

lock_free_hashtable

Lock-free (almost) insertion only hashtable

sharded_mutex

No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.

bolt

The package provides a hierarchical read-write lock

namaste

try-lock-portable-atomic

A lightweight atomic lock

om-rs

Conveniently mount, unmount, (un)lock and power off removable media

microlock

waiting: Small locks and other timing things!

dlock

A lease based distributed lock with support for fencing tokens

scope-lock

Safely extend lifetimes

cbsk_base

locked version cargo crates

merc_sharedmutex

read efficient readers-writer lock based on the busy-forbidden protocol

declarative_lock

A thread-aware resource locking manager for Rust that enforces declaration-before-locking, guaranteeing deadlock freedom and preventing double-locking by tracking resource usage per thread

weblocks

RAII-style Rust wrapper for the Web Locks API (navigator.locks) for wasm32

sudoku

solver library

rust-etcd-utils

A set of utilities for working with etcd in Rust

lockserver

A distributed lock server for coordinating access to shared resources

redlock

distributed locking mechanism built on top of Redis

oxidoor

smart door lock system that uses the ESP32-S3 chip

qm-redis

Redis helper functions

sqlite-cache

SQLite-based on-disk cache

logic-lock

MySQL logic locks implemented over sea-orm

chashmap-async

Concurrent async hash maps with key-scoped locking

locksmith-cli

CLI for extracting Postgres locks from a given SQL statement

chashmap-serde

Fast, concurrent hash maps with extensive API and Serde support

pflock

A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.

pkglock

modify URLs in package-lock.json

coinflip_animation

coinflip animation in the terminal, as a screensaver or just simply to look at

task-notify

Notify async tasks when someone mutates data they're interested in

lockpool

offers a pool of locks where individual locks can be locked/unlocked by key

desk-logind

Bindings for the systemd-logind D-Bus API

ecc608-linux

accessing the ECC608 chip on Linux

procsem

Semaphore used to lock thread/task-spanning sequence of operations

or_poisoned

Unwrap std lock guards in a semantic way

lucchetto

easily call a rust function without holding the GVL lock

oauth-certs

The project fetches oauth certificates from providers during runtime and stores them in static Read / Write lock

fs-dir-cache

A CLI tool for CIs and build scripts, making file system based caching easy and correct (locking, eviction, etc.)

dynamodb_lock

Distributed lock backed by Dynamodb

timed-locks

Smart pointers to tokio::sync locks that either panic or error after a timeout

pallet-balances

FRAME pallet to manage balances

take_lock

a dead simple lock around Option<Box<T>> thats similar in spirit to OnceLock but adds a bit more flexibility by paying a bit in performance

redis-lock

distributed locking backed by Redis

shared-lock

A lock that protects multiple objects at once

proc-lock

cross-process locking API

livestore

Concurrent key-value store with pub/sub capability for Websocket servers

pallet-democracy

FRAME pallet for democracy

async-named-locker

Lock implemented using future

redis-queue-rs

Redis Queue with sync and async support for Rust

rustfs-lock

Distributed locking mechanism for RustFS, providing synchronization and coordination across distributed systems

pallet-vesting

FRAME pallet for manage vesting

dynalock

A lease based distributed locking algorithm with support for DynamoDB

mongo-lock-async

Distributed mutex locks with MongoDB

depit

WIT dependency management

priority-inheriting-lock

A priority-inheriting lock based on Linux futexes

pages-and-pages

Allows control over a manually allocated region of page-aligned memory with support for granular protection and locking of underlying pages

ply_jobs

ability to run background jobs on a schedule

batch-lock

A lock manager with batch-lock support

chashmap

Fast, concurrent hash maps with extensive API

libpostal-sys

Low-level wrappers for libpostal address normalization (with locks to support thread-safe initialization)

envtestkit

Test kit for logics with environment variable involvements

lock_ordering

Lock ordering enforcement at compile time

emf-core-base-rs-ffi

Rust wrapper of the emf-core-base interface

pcat

A dead-lock free parallel cat implementation

ckb-sdk

Rust SDK for CKB

lock-in

A CLI tool to stay locked in what you're working on

groupex

Syncronization primitive that allows acquire lock by index

deadlocker

Bringing builder pattern to defeat deadlocks

lock_cell

A custom locking cell type written in Rust

optimistic_lock_coupling

A General Lock following paper 'Optimistic Lock Coupling: A Scalable and Efficient General-Purpose Synchronization Method'

ckb-script

CKB component to run the type/lock scripts

sling

Sequentially lockign (SeqLock) Ring Buffer

simple-mutex

A mutex more efficient than std and simpler than parking_lot

glock

Granular locking crate for Rust

tuiserial-core

Core data structures and types for tuiserial

ticketed_lock

Ticketed lock system - allows one to separate lock request from the actual waiting

caos

Concurrent Append Only Segment-list

proclock

cross-process locking API

key-rwlock

keyed asynchronous reader-writer locks

distributed-lock-core

Core traits and types for distributed locks

forc-pkg

Building, locking, fetching and updating Sway projects as Forc packages

zsling

Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig

page-lock

reading and writing data from bytes array

parking_method

Obtain parking_lot locks by policy objects

pidfile2

PID Files as process locks in Rust

flag-bearer-mutex

Generic async semaphores

depit-cli

WIT dependency manager

libmemtester

testing memory for faults

key-lock

mutual exclusion by keys

ordered-locks

Compiletime deadlock avoidance

bad_lock

lock/unlock files with password by aes-128-cbc

ckbes

CKB Easy Script is a framework for developing ckb contracts

pezpallet-balances

FRAME pezpallet to manage balances

dfmutex

Deadlock-free Mutex locks

read-copy-update

locking primitive

hubby

lock service

throttle_lock

Throttle can be used to monitor and limit user activity

cocklock

distributed locking mechanism built on top of Postgres/CockroachDB

lock_many

Retry-based locking multiple mutexes at once

anode

Concurrency library for Rust

idable

some sequence with no lock

barriers

A barrier spin lock implementation

mongo-lock

Distributed mutex locks with MongoDB

thread-lock

A wrapper that locks non-Send and non-Sync data to a specific thread

proc-lock-api

APIs for the proc-lock crate

genref

Vale's generational references in Rust

spin-lock

spin lock implemented by the standard facilities

mongodb-lock

distributed locking backed by Mongodb

env-guard

Set and lock environment variables for tests

pezpallet-democracy

FRAME pezpallet for democracy

redlock-async

distributed locking mechanism built on top of Async Redis

lock_tree

Prevent deadlocks at compile time. A standalone republication of the netstack3 lock-ordering crate, part of Google's Fuchsia OS.

unlink

Lock free linked list

essential-lock

A minimal crate containing Essential's locking method that is safe to use in async code

allenap-flock-experiment

Interactive command-line tool to experiment with flock(2) locks

rw_lease

Fast Reader-Writer lock with reader draining support. Based on a single (parameterisable) atomic usize.

fcntl

Wrapper around fcntl (2) and convenience methods to make interacting with it easier

arbitrary-lock

Lock by arbitrary keys

proclock-api

APIs for the proclock crate

lockspot

let's ask package-lock some questions

tetromino-xlock-bindings

Rust bindings for xlock, suitable for writing a custom "mode"

striped-lock

Striped Lock for Rust

qrwlock

Fair queued read-write lock

sero

lightweight library for maintaining a shared store of locks

pezpallet-vesting

FRAME pezpallet for manage vesting

redlock_batched

Creating, updating and deleting redis locks (Redlock) in batches

seamapi-rs

client for Seam

megalock

X11 xlock replacement

redlock-rs

[DEPRECTAED] Use redlock instead

arc_map

A Map of Arc<Mutex<V>> that eases the access of indivdual members

async-file-lock

Asynchronous file lock that can auto lock and auto seek

lock_order

macro for helping produce a deterministic lock ordering to prevent deadlocks

name_locker

interface for asynchronous name lockers, that can run an async task with lock on a given name

chashmap-next

Fast, concurrent hash maps with extensive API

thinkofname/think_ecs

Source code of the game Univercity: https://store.steampowered.com/app/808160/UniverCity/

asar-snes

Rust bindings for Asar (https://github.com/RPGHacker/asar)

relock

Distributed async locking using Redis

lock

Lock your system. Supports macOS, Linux, and Windows.

hiatus

Debug concurrent programs by choosing specific execution traces

global

variables without macros

redislock

distributed locking mechanism built on top of Redis

ghetto-lock

Memcache backed ghetto lock implementation