CRDTosphere Banner

CRDTosphere

Conflict-free Replicated Data Types for Embedded Systems

A comprehensive Rust library providing memory-efficient, real-time CRDTs designed specifically for safety-critical embedded systems in automotive, robotics, IoT, and industrial domains.

Why CRDTosphere?

🚀

Zero Allocation

Fixed-size arrays and compile-time memory allocation for predictable embedded systems performance.

Real-Time Ready

Bounded execution times and deterministic operations suitable for hard real-time constraints.

🔒

Safety Critical

ASIL-compliant implementations with comprehensive validation and error handling.

🔧

Hardware Atomic

Lock-free concurrent operations using hardware atomic primitives for multi-core systems.

🌐

Domain Specific

Specialized CRDTs for automotive, robotics, IoT, and industrial automation use cases.

📊

Memory Bounded

Configurable memory limits with compile-time validation and runtime monitoring.

CRDT Types Available

Counters

GCounter

Grow-only counter for increment operations

PNCounter

Increment/decrement counter with dual arrays

Registers

LWWRegister

Last-writer-wins register with timestamps

MVRegister

Multi-value register for concurrent updates

Sets

GSet

Grow-only set for add-only operations

ORSet

Observed-remove set with add/remove support

Maps

LWWMap

Last-writer-wins map for key-value storage

Domain-Specific Applications

🚗

Automotive

Safety-critical sensor fusion, ASIL-compliant data structures, and real-time vehicle coordination.

Learn More →
🤖

Robotics

Multi-robot coordination, shared mapping, status synchronization, and signal coordination.

Learn More →
🌐

IoT

Device registries, sensor networks, distributed data collection, and edge computing.

Learn More →
🏭

Industrial

Equipment monitoring, process control, maintenance scheduling, and factory automation.

Learn More →

Quick Start

Add to your Cargo.toml

[dependencies]
crdtosphere = { version = "0.1.0", features = ["hardware-atomic"] }

Basic Usage

use crdtosphere::prelude::*;

// Create a grow-only counter
let mut counter = GCounter::<DefaultConfig>::new(1);
counter.increment()?;
assert_eq!(counter.value(), 1);

// Create a last-writer-wins register
let mut register = LWWRegister::<i32, DefaultConfig>::new(1);
register.set(42, 1000)?;
assert_eq!(register.get(), Some(&42));