Skip to content

Home

Jump to bottom
Dmitry Olegovich Sorokin (@sorydima) edited this page Dec 27, 2025 · 1 revision

DeCub: Decentralized Compute Platform

DeCub (short for Decentralized Compute Platform) is an open-source distributed computing infrastructure project developed by REChain-Network-Solutions. It provides a Byzantine Fault Tolerant (BFT) system for executing computational workloads across decentralized clusters — aiming to replace centralized cloud models with a secure, resilient, and scalable peer-to-peer compute fabric. ([GitHub][1])

Overview

DeCub is engineered as a next-generation decentralized compute system that supports distributed execution, storage, and state synchronization across a global network of nodes. Its architecture blends classical distributed systems techniques (e.g., RAFT consensus) with global BFT coordination, content-addressable storage, CRDT-based metadata, and advanced cryptographic proofs to ensure consistency, integrity, and fault tolerance. ([GitHub][1])

The codebase is primarily implemented in Go and organized into multiple modules covering various aspects like control plane, snapshotting, gossip protocols, catalog management, object storage, and cryptography. ([GitHub][1])

Architecture

DeCub defines a five-layer architecture, each with clear responsibilities:

1. Application Layer

Provides workload orchestration, resource allocation, decentralized service discovery, and APIs (REST/gRPC) for external integration. It enables containerized deployments and lifecycle management across clusters. ([GitHub][1])

2. Consensus Layer

  • Local Consensus (RAFT): Ensures strong consistency within individual clusters.
  • Global Consensus (BFT): Ensures Byzantine fault tolerance across the entire decentralized network.
  • Hybrid Two-Phase Commit (2PC): Coordinates transactions that span local and global domains. ([GitHub][1])

3. Storage Layer

Supports flexible data persistence and synchronization:

  • Content-Addressable Storage (CAS) for immutable blob storage.
  • CRDT Catalog for conflict-free metadata replication.
  • Distributed Ledger for append-only transaction logs.
  • Object Storage with S3-compatible interface. ([GitHub][1])

4. Network Layer

Handles peer-to-peer communication and state propagation via:

  • Gossip protocols using libp2p.
  • Anti-entropy synchronization with Merkle verification.
  • NAT traversal and automatic peer discovery.
  • Load balancing across nodes. ([GitHub][1])

5. Security Layer

Implements cryptographic safeguards:

  • Hierarchical key management.
  • ECDSA signatures for authentication.
  • TLS encryption for secure transport.
  • Zero-knowledge proofs for privacy-preserving verifications. ([GitHub][1])

Key Concepts

Decentralized Consensus

DeCub merges RAFT for fast, reliable cluster-level consensus with BFT consensus for global state finality, enabling trustless operation even if up to one-third of nodes behave maliciously. ([GitHub][1])

Content-Addressable Storage

Data is stored based on its cryptographic hash, enabling efficient deduplication, verification, and decentralized distribution. ([GitHub][1])

Conflict-Free Replicated Data Types (CRDTs)

CRDTs maintain consistent metadata across all nodes without locking or central coordination, enabling scalable replication. ([GitHub][1])

Gossip Protocols and Anti-Entropy

Nodes propagate state deltas through gossip, while anti-entropy reconciles differences using Merkle tree verification for integrity. ([GitHub][1])

APIs and Interfaces

DeCub exposes programmable API endpoints for:

  • Catalog Management: POST /catalog/snapshots, GET /catalog/query, etc. ([GitHub][1])

  • Gossip Control: GET /gossip/status, POST /gossip/sync, and delta exchanges. ([GitHub][1])

  • Consensus Transactions: POST /consensus/transactions, block/transaction queries. ([GitHub][1])

  • Object Storage: PUT /storage/objects/{id}, GET /storage/objects/{id}, and chunk management. ([GitHub][1])

These APIs enable external services and applications to register snapshots, propagate state, query metadata catalogs, and manage distributed storage. ([GitHub][1])

Data Flow & Lifecycle

DeCub defines clear data paths for snapshot creation, registration, replication, and restoration:

  1. Snapshot Creation: Chunk data and generate SHA-256 hashes.
  2. Upload & Registration: Store chunks in CAS and register metadata in CRDT catalog.
  3. Global Consensus: Register changes via the global consensus layer.
  4. Replication & Sync: Use gossip to propagate and reconcile state.
  5. Retrieval: Fetch and reassemble snapshots via verified chunk hashes. ([GitHub][1])

This lifecycle ensures that data is verifiable, durable, and efficiently synchronized across the network. ([GitHub][1])

Proof Systems and Security

DeCub leverages cryptographic proof systems such as Merkle proofs to verify data integrity and enable trustless synchronization without centralized validation points. ([GitHub][1])

Example (pseudocode for Merkle proof verification):

func VerifyMerkleProof(root []byte, proof MerkleProof, leaf []byte, index int) bool {
    hash := leaf
    for _, sibling := range proof.Hashes {
        ...
    }
    ...
}

This ensures that any node can independently verify the inclusion and correctness of data chunks in the global dataset. ([GitHub][1])

Performance & Goals

DeCub aims for high throughput, fault tolerance, and wide scalability in decentralized environments. Its hybrid consensus and layered design target workloads where security, resilience, and decentralization matter more than traditional centralized cloud performance. ([GitHub][1])

Repository Structure

Typical folders include:

  • cmd/ – executable entry points.
  • decub-* modules – subsystems (catalog, gossip, storage, crypto).
  • config – configuration assets.
  • tests – integration & unit tests.
  • Deployment manifests (Docker, Kubernetes).
  • Implementation TODOs and test plans. ([GitHub][1])

Licensing

The project is distributed under the BSD-3-Clause License, promoting open usage and modification with minimal restrictions. ([GitHub][1])

Context in Decentralized Compute & DePIN

DeCub is part of a broader technology trend toward Decentralized Physical Infrastructure Networks (DePIN) and decentralized compute frameworks, which seek to challenge centralized cloud paradigms by distributing compute and data workloads across peer-to-peer networks. ([Reddit][2])

Compared to other projects aiming at DePIN computing markets or GPU sharing, DeCub focuses on protocol-level consistency guarantees and cryptographic verification, addressing one of the key challenges in decentralized compute: trustless correctness of execution and state. ([Reddit][3])

Clone this wiki locally