Lib.rs

parking_lot

More compact and efficient implementations of the standard synchronization primitives

spin

Spin-based synchronization primitives

rayon

work-stealing parallelism for Rust

dashmap

Blazing fast concurrent HashMap for Rust

thread_local

Per-object thread-local storage

async-lock

Async synchronization primitives

crossbeam

Tools for concurrent programming

ringbuf

Lock-free SPSC FIFO ring buffer with direct access to inner data

flume

A blazingly fast multi-producer channel

async-channel

Async multi-producer multi-consumer channel

threadpool

A thread pool for running a number of jobs on a fixed set of worker threads

oneshot

spsc channel with (potentially) lock-free non-blocking send, and a receiver supporting both thread blocking receive operations as well as Future based async polling

triomphe

A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)

neon

A safe abstraction layer for Node.js

loom

Permutation testing for concurrent code

thread-priority

managing threads priority and schedule policies

arcstr

A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings

jobserver

GNU Make jobserver for Rust

sled

Lightweight high-performance pure-rust transactional embedded database

kanal

The fast sync and async channel that Rust deserves

sync_wrapper

enlisting the compiler's help in proving the absence of concurrency

corosensei

A fast and safe implementation of stackful coroutines

parking

Thread parking and unparking

leaky-bucket

A token-based rate limiter based on the leaky bucket algorithm

rtrb

A realtime-safe single-producer single-consumer ring buffer

lockfree-object-pool

A thread-safe object pool collection with automatic return and attach/detach semantics

thingbuf

I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.

may

Rust Stackful Coroutine Library

stateright

A model checker for implementing distributed systems

atomic_float

Floating point types which can be safely shared between threads

state

safe and effortless global and thread-local state management

boxcar

A concurrent, append-only vector

cargo-green

Cargo plugin and $RUSTC_WRAPPER to sandbox & cache cargo builds and execute jobs remotely

bus

A lock-free, bounded, single-producer, multi-consumer, broadcast channel

flurry

Rust port of Java's ConcurrentHashMap

gst-plugin-threadshare

GStreamer Threadshare Plugin

hwlocality

Idiomatic Rust bindings for the hwloc hardware locality library

local-channel

A non-threadsafe multi-producer, single-consumer, futures-aware, FIFO queue

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

try-lock

A lightweight atomic lock

ipc-channel

A multiprocess drop-in replacement for Rust channels

throttle-server

Provide semaphores for distributed systems via an http interface

scheduled-thread-pool

A scheduled thread pool

concurrent-queue

Concurrent multi-producer multi-consumer queue

radium

Portable interfaces for maybe-atomic types

thread-id

Get a unique thread ID

ratelimit

ratelimiter that can be shared between threads

executors

A collection of high-performance task executors

jod-thread

std::thread which joins on drop by default

futures-intrusive

Futures based on intrusive data structures - for std and no-std environments

mpi

Message Passing Interface bindings for Rust

tachyonix

A very fast asynchronous, multi-producer, single-consumer bounded channel

orx-concurrent-vec

A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations

once_map

Single assignment and lazy maps

surrealkv

A low-level, versioned, embedded, ACID-compliant, key-value database for Rust

typedmap

A hash map (dash map). A type of value is defined by trait implemented on key type

pend

do now, wait later – tiny job runner

guardian

owned mutex guards for refcounted mutexes

process_control

Ergonomically run processes with limits

shuttle

testing concurrent Rust code

mpstthree

implementing Multiparty Session Types for 2 or more participants

inline-array

efficient immutable inlinable byte array

crossbeam-channel

Multi-producer multi-consumer channels for message passing

atomig

Generic, convenient and lock-free std atomics via Atomic<T>. Can be used with many primitive types (including floats) and with custom types.

async-condvar-fair

Condition variables for async Rust

sdd

Scalable lock-free delayed memory reclaimer

parallel-sh

Execute commands in parallel

amity

Concurrency algorithms

desync

A hassle-free data type for asynchronous programming

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

turnkeeper

An asynchronous, recurring job scheduler for Tokio with support for CRON, interval, and weekday/time schedules, plus retries, cancellation, and observability

paralight

A lightweight parallelism library for indexed structures

ppl

A structured parallel programming library for Rust

rclite

small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs

disruptor

Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)

uid

creation of unique IDs

idr-ebr

An efficient concurrent ID to object resolver

runnel

the pluggable io stream. now support: stdio, string io, in memory pipe

clashmap

Sharded hashmap suitable for fast concurrent access

lockable

offers hash map, hash set and cache data structures where individual entries can be locked

indicatif-log-bridge

Bridge the log crate and indicatif to stop log lines from mixing up with progress bars

mco

Rust Coroutine Library like go

fault-injection

fault injection, concurrency delay injection, and error source annotation

open-coroutine

efficient and generic stackfull-coroutine library

safe-lock

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

happylock

Free deadlock prevention

mutex

An abstraction over closure-based mutexes

botcore

Production-grade asynchronous bot engine with enterprise observability features

synchronized

convenient macro for synchronizing code in multithreading

atomic-time

AtomicDuration, AtomicOptionDuration, AtomicSystemTime, AtomicOptionSystemTime, AtomicInstant and AtomicOptionInstant for Rust

grip-grab

A faster, more lightweight ripgrep alternative

pausable_clock

A source of time information that can be paused and resumed

sea-streamer

🌊 The stream processing toolkit for Rust

st3

A very fast lock-free, bounded, work-stealing LIFO queue

seize

Fast, efficient, and predictable memory reclamation for concurrent data structures

workerpool

A thread pool for running a number of jobs on a fixed set of stateful worker threads

rtactor

An Actor framework specially designed for Real-Time constrained use cases

deqp-runner

A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline

wd_tools

tools for rust

mcslock

Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock

orx-concurrent-iter

A thread-safe and ergonomic concurrent iterator trait and efficient lock-free implementations

evolution

Efficiently evolve your old fixed-length data files into modern file formats

rearch

Re-imagined approach to application design and architecture

ordered-channel

A channel that always receives messages in the correct order, even if they were sent out of order

chili

low-overhead parallelization library

gol_engines

Tools for Conway's Game of Life

fieldx

Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax

sync_file

Files that can be read concurrently

shred

Dispatches systems in parallel which need read access to some resources, and write access to others

threadpools

Efficient, configurable, zero-dependency thread pool implementations. Flexible and usable for a wide variety of applications.

par-core

Switchable parallel execution core

yazi-scheduler

Yazi task scheduler

rcu_cell

a lockless rcu cell implementation

arrayfire

high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (CUDA…

flo_scene

Entity-messaging system for composing large programs from small programs

threadbound

Make any value Sync but only available on its original thread

onering

High throughput synchronous queue

recloser

A concurrent circuit breaker implemented with ring buffers

infinitree-backends

Embedded, encrypted database with tiered cache -- backends

khonsu

Software Transactional Memory in Rust for Apache Arrow

rs-event-emitter

simulate promise implementation for rust

oqueue

Non-interleaving multithreaded output queue

rtthost

RTT (Real-Time Transfer) client

synchronoise

Synchronization primitives that build upon the standard library

loole

A safe async/sync multi-producer, multi-consumer channel

io-reactor

Concurrent I/O resource management using reactor pattern

atomic-file-install

For atomically installing a file or a symlink

mea

A runtime-agnostic library providing essential synchronization primitives for asynchronous Rust programming

rsevents

Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores

atomptr

A safe copy-on-write wrapper around AtomicPtr with some extra tricks

trauma

Simplify and prettify HTTP downloads

television

A cross-platform, fast and extensible general purpose fuzzy finder TUI

pumps

Eager streams for Rust

nbio

Non-Blocking I/O

magnetic

Low-latency lock-free queues

leapfrog

A fast, lock-free concurrent hash map

paradis

Parallel processing with disjoint indices

pueue

A cli tool for managing long running shell commands

callysto

Stream processing framework

waker-fn

Convert closures into wakers

batch-aint-one

I got 99 problems, but a batch ain't one

atom_box

A safe idiomatic Rust implementation of Atomic Box using hazard pointers

omango

Concurrency collections

async-local

For using thread locals within an async context across await points

tracing-mutex

Ensure deadlock-free mutexes by allocating in order, or else

thingvellir

a concurrent, shared-nothing abstraction that manages an assembly of things

locktick

Automated lock accounting & profiling

crossbeam-utils

concurrent programming

chalamet_pir

Stateful, Single-Server Private Information Retrieval for Key-Value Databases

razel

a command executor with caching for data processing pipelines

elysees

A fork of triomphe, now with more pointer trickery

renoir

Reactive Network of Operators In Rust

krecik

Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL

rtic-sync

Synchronization primitives for asynchronous contexts

sanitizers

Interfaces and FFI bindings for the sanitizers interfaces

piz

piz (a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

melodium

Flow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely

d-engine

A lightweight and strongly consistent Raft consensus engine written in Rust. It is a base to build reliable and scalable distributed systems.

nuclei

Proactive IO & runtime system

lasso2

A multithreaded and single threaded string interner that allows strings to be cached with a minimal memory footprint, associating them with a unique key that can be used to retrieve them at any time

openfga-client

Type-safe client SDK for OpenFGA with optional Authorization Model management and Authentication (Bearer or Client Credentials)

pi_arr

lock-free & auto-expansion array

myriam

Actor model implementation for local and remote actors

spinning_top

spinlock crate based on the abstractions provided by lock_api

cross-locks

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

progress-token

tracking progress of long-running tasks

gabriel2

Indeed, an actor library based on Tokio, written in Rust

jobflow

Executes jobs in order

sharded_mutex

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

atomic-arena

Generational arena that allows reserving keys from other threads

siafu

Ergonomic job scheduling library for Rust

fork_union

Minimalistic scoped thread-pool designed for SIMT-style 'Fork-Join' parallelism

scx_userspace_arena

interacting with BPF arenas from userspace in sched_ext schedulers

tc-transact

Traits and locking utilities for a TinyChain transaction

circuitbreaker-rs

A production-grade, zero-boilerplate, lock-efficient, observability-ready Circuit Breaker library

speare

actor-like thin abstraction over tokio::task and flume channels

per-thread-mutex

Synchronization lock designed for wrapping thread-unsafe C libraries

atomic-take

Atomically take a value out of a container once

bcast

Low latency broadcast (SPMC) buffer designed to work with shared memory

ballista-scheduler

Ballista Distributed Compute - Scheduler

concurrent-map

a lock-free linearizable B+ tree

transactional

optimistic lock-free confirmation-based transactional model for Rust

nexus-acto-rs

Actors

wb_async_utils

working with async code

ostd

Rust OS framework that facilitates the development of and innovation in OS kernels

aarc

Atomically updatable variants of Arc and Weak for lock-free concurrency

pbrt-r3

pbrt-v3

orx-parallel

High performance, configurable and expressive parallel computation library

choir

Task Orchestration Framework

splaycast

Stream-specific broadcast channel

que

A high performance channel with optional backpressure, interprocess capability, and a multiconsumer mode

mirai-annotations

Macros that provide source code annotations for MIRAI

liner_broker

Redis based message serverless broker

scx_bpfland

A vruntime-based sched_ext scheduler that prioritizes interactive workloads. https://github.com/sched-ext/scx/tree/main

duchess

Silky smooth Java-Rust interop

no_deadlocks

A Runtime Deadlock Debugger

channel

Rust advanced queue library

mintex

minimal mutex

range-lock

Range lock for std::vec::Vec

arccstr

Thread-safe, reference-counted null-terminated immutable strings

iterator_ilp

Iterator extensions for instruction-parallel reductions

sync42

synchronization tools

protoflow

implements flow-based programming (FBP) for Rust using Protocol Buffers messages

atomic-wait

Cross-platform atomic wait and wake (aka futex) functionality

stupid_utils

that provides some simple and maybe stupid or useful tools

gasket

Staged Event-Driven Architecture (SEDA) framework

messaging_thread_pool

aiding the creation of typed thread pool of objects that is communicated with via channels

schedules

A lightweight Rust library for managing operations across multiple time scales

rc_event_queue

VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue

blazemap

Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map

ptr_cell

Thread-safe cell based on atomic pointers

fast-stm

Performance-focused implementation of software transactional memory. Allows composable atomic operations

test_cpu_parallel

Generate CPU- or memory-intensive workloads for benchmarking

atomic-shim

Atomic types for unsupported platforms

pubsub-bus

Thread-safe one-to-many publish-subscribe event system. Simple and easy to use. It just works (hopefully).

testbench

Testing and benchmarking tools for concurrent Rust code

rcron

cron job scheduling for rust

keepcalm

shared types for multi-threaded programs

balter

A load/stress testing framework

irox-threading

Blocking and Asynchronous Threading Tools

sovran-arc

Memory management swift-isms brought to Rust

readlock

A weird alternative to Arc<RwLock<T>>

atomic

Generic Atomic<T> wrapper type

resilient-rs

fault tolerance, including retry strategies, backoff mechanisms, and failure handling

atomic-lend-cell

lending immutable references across threads with explicit owner-borrower semantics, offering both atomic reference counting and lightweight flag-based implementations

lock-free-static

Lock-free static variables

batched-queue

A high-performance, highly-concurrent batched queue implementation for Rust

namaste

congee

ART-OLC concurrent adaptive radix tree

par_slice

Slices that may be accessed from multiple threads with different levels of safety

atomx

Thread safe data structures based on atomic data types

rs-store

Redux Store for Rust

node-replication

An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures

esl01-indexedlog

Append-only on-disk storage with integrity checks and indexing support

portable_atomic_enum

An attribute to create an portable atomic wrapper around a C-style enum

rt

A real-time operating system capable of full preemption

cfavml

CF's Accelerated Vector Math Library providing SIMD optimzied routines for vector operations

virtual-buffer

A cross-platform library for dealing with buffers backed by raw virtual memory

clave

Midi click-track generator

elasticq

A thread-safe, dynamically resizable circular buffer for high-throughput scenarios

pi_append_vec

Only supports append vectors, lock free

rust-releases

Find, index and obtain all officially available Rust releases

round_mult

A tiny library to round a number up or down to a multiplier

acts-next

a fast, tiny, extensiable workflow engine

lockmap

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

kcr_execution_furiko_io

Kubernetes Custom Resource Bindings

win-kernel

windows-kernel

quartz

Port of the original Java Quartz Scheduler to Rust

fdup

find duplicate files recursively and in parallel

affinitypool

running blocking jobs on a dedicated thread pool with CPU core affinity

swimos_introspection

SwimOS Agent Introspection

crosstermion

crossterm, without ties to termion

lock_api

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

lockfree

concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers

semka

Semaphore implementation

utils-atomics

Various atomic utils

nexus-actor-utils-rs

Nexus Actor

linked

Create families of linked objects that can collaborate across threads while being internally single-threaded

may_actor

Actor library based on MAY

rt-history

An RT-safe history log with error checking

simd-itertools

SIMD-accelerated alternatives for common operations like contains, max, find etc

latches

A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks

orchestrator_lock

A Mutex whose access order is managed by a separate thread

ibuf

A memory buffer pool implementation

tlrepo

Thread-local git2::Repository, shareable across threads

svix-ksuid

A pure Rust and fully tested KSUID implementation

sigq

Queue that signals waiting consumers about node availability

narust-158

reimplementation of OpenNARS 1.5.8

rds_lock

asynchronous redis distributed read-write lock implementation based on tokio and redis-rs

opentalk-janus-client

A janus client implementation for use in OpenTalk

timely-master

A low-latency data-parallel dataflow system in Rust

someday

Lock-free MVCC primitive

cubecl-hip-sys

Rust bindings for AMD ROCm HIP runtime libraries used by CubeCL

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

sync-arena

thread-safe arena allocator

infinitree

Embedded, encrypted database with tiered cache

rusturnate

A sync or async mutex, with or without timeouts

active_standby

A concurrency primitive for high concurrency reads

debugrs

logger that mimics the npm debug module

rex-sm

Hierarchical state machine

discord_client_rest

Undetected discord client rest API reimplementation

tether-agent

Standardised use of MQTT and MessagePack for inter-process communication

timely_communication

Communication layer for timely dataflow

pawawwewism

a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3

atomic-counter

Atomic (thread-safe) counters for Rust

treiber_stack

A lockless, thread-safe, atomic linked-list

kube-leader-election

Leader election implementations for Kubernetes workloads

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

actm

Tiny async actors framework for rust

simple_coro

(ab)using async/await to write simple state-machine based coroutines

k-lock

A fast mutex for short critical sections

walle-core

OneBot lib in Rust

io-pipe

A fast and thread-safe library for creating multi-writer and single-reader pipelines in Rust

wl-client

Safe client-side libwayland wrapper

lmml

LMML Music Macro Language

gst-plugin-inter

GStreamer Inter Plugin

rearch-tokio

Re-imagined approach to application design and architecture

rocketmq-client-v4

rocket mq rust client for remote protocol. works on rocket mq V4

oneshot-uniffi

Patched version of oneshot specifically for the UniFFI project. This removes the loom target and dependency which helps with UniFFI’s downstream consumers

command_history

managing command history in Rust applications

thread_io

performing I/O in background thread

visa-device-handler

handle NI-VISA connections and simplify its use

direct_ring_buffer

A high-performance, lock-free ring buffer for single-producer, single-consumer scenarios

daemonbit

Cross-platform daemon lifecycle primitives

flag-bearer-mutex

Generic async semaphores

write_atomic

Write to files atomically

timeslice

periodic time slice scheduler

constellation-rs

Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs

process_anywhere

Tools for running computer processes locally and remotely via SSH

antidote

Poison-free versions of the standard library Mutex and RwLock types

dapt

serializing and unseralizing unstructured data

papaya

A fast and ergonomic concurrent hash-table for read-heavy workloads

creche

A replacement for std::process::Command and related types in the standard library. Runs single processes, and pipelines of processes, with configuration of file descriptors and environment for each child process.

rsvow

A Rust-like implementation of JavaScript's Promise mechanism

nbus

A lock-free, bounded, single-producer, multi-consumer, broadcast channel

swap-buffer-queue

A buffering MPSC queue

rust-lockless-slotmap

A (mostly) lockless slotmap implementation in Rust

async_once

async once tool for lazy_static

send_cells

Safe and unsafe cells implementing Send/Sync

atomicring

AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer

thread_map

Types that are simple and easy-to-use alternatives to the std::thread_local macro

mpsc_requests

mpsc channels but with a response

mm1-node

M/M/1! Queueing, do you speak it?!

blazingqlog

QUIC QLOG parser written in Rust

ccutils

Collection of utils from the CylonCore project

unstacked

Lock-free, no-std concurrent stack for Rust

EMCompute

fast , simple and cross-platform parallel computing library

rust_kits

kits

resilient-rabbitmq-client

Easily deploy resilient RabbitMQ consumers and publishers

kc

Kayla's (line) counter (of code) :)

parallel_worker

A parallel worker implementation in Rust. Allows to start tasks in parallel and receive the results blocking or non-blocking.

komora-sync

Synchronization structures for the komora db project

crossbeam-queue

Concurrent queues

txn_lock

support transactional versioning

cdk-from-cfn

Turn AWS CloudFormation templates into AWS CDK applications

hab-rs-api-client

Bindings for openHAB REST API

pacwrap-agent

Executable agent for conducting containerized transactions

sync-cell-slice

Cells and slices that are accessible from multiple threads

pargraph

Operator based parallel graph processing

jwalk-meta

Filesystem walk performed in parallel with streamed and sorted results

qeztorncodegen

* The development of Torn's API v2 is still ongoing. * If selections remain unaltered, they will default to the API v1 version. * Unlike API v1, API v2 accepts both selections and IDs as path and query parameters…

ibag

A thread-safe, immutable bag for holding any value

resolver

Expression evaluator

fuyu

programming language

electrologica

High performance concurrent primitives for Rust

patrolilo

Job scheduler with integrated NTFY notifications

bus_queue

Lock-free Bounded non-Blocking Pub-Sub Queue

crossbeam-skiplist-mvcc

Support MVCC (Multiple Version Concurrent Control) for crossbeam-skiplist

blueprint-producers-extra

Additional job call producers for the Blueprint SDK

sovran-state

state management for Rust

tc-scalar

TinyChain's scalar value enum, including concurrently-resolvable op definitions and references

xstm

A Rust-implemented Software Transactional Memory (STM) library using TL2 (Transactional Locking II) algorithm

asyncgit

allow using git2 in a asynchronous context

umpx

Collection of ump extensions

idgenerator-thin

Shorter ID and faster generation with a new snowflake drift algorithm. The core is to shorten the ID length, but also can have a very high instantaneous concurrent processing capacity (50W/0…

openmp-reducer

OpenMP-style reducers

atomicbox

Safe atomic pointers to boxed data

rrddmma

RDMA

fluxion

actor framework written in rust and designed for distributed systems

atomic-server

Create, share and model Atomic Data with this graph database server. Run atomic-server without any arguments to start the server. Use --help to learn about the options.

task_scheduler_rs

A Rust-based scheduler with basic functionality, focused on adding tasks and handling actions like execute, pause, and shutdown using channels for task communication

relay_channel

A single-producer, single-consumer channel where the sender waits for the receiver to receive the message before returning

tensr

A high-performance, cross-platform, multi-backend tensor/array library for Rust

alopt

providing efficient synchronization primitives that integrate Option into their design

concurrent-slotmap

A lock-free concurrent slotmap

aranya-util

needed by other Aranya crates

monch

Inspired by nom, but specifically for strings

thermal_hydraulics_rs

A Thermal Hydraulics Library with some useful traits,enums and functions for heat transfer and fluid mechanics

signals2

A thread-safe signal/slot library inspired by boost::signals2

atomic_enum

An attribute to create an atomic wrapper around a C-style enum

fast-async-mutex

lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)

streameroo

Compilation of mini-frameworks & utilities for data-streaming applications

fast-steal

特别快的多线程库，支持超细颗粒度的任务窃取

api-rate-limiter

rate limiter for Rust APIs

conquer-once

Synchronization primitives for lazy and one-time initialization

shipyard_scenegraph

Scenegraph for Entity Component System

non_blocking_mutex

NonBlockingMutex is currently the fastest way to do expensive calculations under lock, or do cheap calculations under lock when concurrency/load/contention is very high

drcp-format

Parse and write DRCP and literal definition files