Foundation components

fluxrig is a high-performance orchestration engine designed to harmonize complex signal flows across heterogeneous environments. Whether bridging air-gapped industrial sensors, routing high-capacity payment transactions, or managing distributed IoT fleets, the platform provides a unified, configuration-driven foundation for mission-critical operations.

Core Pillars

1. Deterministic Data Plane: We treat all data—from Modbus registers to ISO8583 financial messages—as high-fidelity signals passing through a professional studio mixing console. Every signal is serialized using Deterministic CBOR (RFC 8949) to ensure bit-perfect integrity and auditability.
2. Sovereign Edge Autonomy: The Rack (Edge Node) operates with full independence. It continues to process data, perform transformations, and maintain local compliance even during total backhaul or cloud connectivity failures.
3. Unified Control Plane (UCP): The platform enables the management of thousands of heterogeneous edge nodes as a single, cohesive entity through the Mixer's centralized policy, identity registry, and real-time telemetry aggregation.

Strategic Alignment

• Industrial (UNS): Implements the Unified Namespace (UNS) and Industrial DataOps principles to transform fragmented OT silos into a contextualized, event-driven hierarchy.
• Payments (PCI-DSS): Employs the Stateless Context (Coat Check) pattern to ensure sensitive financial data remains isolated while keeping the primary "Hot Path" lean and compliant.
• DevOps & SRE: Delivers Zero-Agent Observability (OpenTelemetry) and Configuration-as-Code deployments, reducing operational overhead and firewall complexity.

This document outlines the architectural pillars that power the rig.

Note: This page focuses on Architectural Drivers. For the complete list of libraries and tools (including Databases, UI, and Testing), see the Technology Stack for details on the underlying components.

The nervous system (NATS)

The backbone of fluxrig is a resilient, distributed messaging mesh that provides the connective tissue for the entire patchbay.

• Goal: Connect distributed racks securely with guaranteed delivery.
• The tool: NATS JetStream (by Synadia).
• Why:
  • Resilient mesh: Unlike traditional load balancers, NATS creates a pervasive mesh that handles connectivity gaps automatically.
  • Sovereign Edge Autonomy: We leverage "Leaf Nodes" at the edge. A Rack operates with Sovereign Continuity, continuing to process data and perform local transformations even during total backhaul or cloud connectivity failures.
  • Financial grade reliability: We use JetStream to ensure at-least-once delivery and strict ordering, critical for financial events and command protocols.
  • High-Fidelity Determinism: Low-bandwidth serialization via CBOR (RFC 8949) ensures bit-perfect integrity and responsiveness over satellite or cellular links.

Stateless context (the coat check)

To maintain performance and compliance (like PCI-DSS), we avoid bloating messages with heavy state. Instead, we use a "Coat Check" pattern where sensitive context is stored in a distributed key-value store and retrieved only when needed.

TIP

This pattern keeps the "Hot Path" lean and ensures sensitive data like PANs never leave secure zones. See the Message Flow for technical details.

The dual-pipeline strategy

We distinguish sharply between Business Data (Transactions) and Operational Data (Metrics/Logs). This requires two distinct pipeline patterns.

Pipeline A: Business Data pipeline (Gears & Wasm)

• Goal: Process high-performance documents (ISO8583, IoT sensors) and flexible data transformations.
• The strategy: An extensible architecture designed for both performance and custom plugins.

  • Native gears: Optimized Go logic for latency-sensitive protocols like ISO8583 and financial switching.

  • WebAssembly (Wasm): [Roadmap] Support for sandboxed, polyglot plugins (Rust, C++, TypeScript), allowing for safe third-party extensions.

  • Bento integration: A rich ecosystem of [Standard] cloud connectors (File, Stdout, HTTP) and powerful mapping (bloblang).

    NOTE

    While Bento supports 100+ connectors (S3, Kafka, AMQP), the v0.4.5-dev+e5eff62 Standard Binary focuses on core I/O. Additional connectors are available via custom builds or the Enterprise tier.

  • Side-Chain Inference: [Roadmap] Asynchronous AI logic for non-deterministic tasks like fraud scoring or synthetic test generation.

Pipeline B: Operational Data pipeline (OpenTelemetry)

• Goal: Monitor the health of the rig and trace transactions.
• The tool: OpenTelemetry.
• Why: Industry standard for unification of metrics, logs, and traces.
• Strategy: The Non-Intrusive Signal Tap.
  • Embedded library: We use the OTel Go SDK directly inside the Rack binary; no sidecars or external agents required.
  • Signal tapping: Telemetry is tapped directly from the execution path and diverted for monitoring without impacting the integrity of the primary flow.
  • Snake transport: Metrics and traces are serialized and pushed over the high-fidelity Snake connection (fluxrig.stats) to the Mixer.
  • Aggregation: The Mixer collects these streams and forwards them to the storage layer for deep analytics.

Deep storage (data sovereignty)

• The philosophy: "Your data is yours".

• The solution: Data is persisted in open standards, ensuring a Lossless Audit Trail.

  • Standard tier: Zero-dependency local storage using parquet and DuckDB (Included in OSS).
  • Enterprise tier: [Roadmap] Distributed high-availability storage with support for external backends (e.g., ClickHouse, or S3-backed data lakes).

• The benefit: Query your audit logs with any modern tool (Spark, pandas, Athena) without vendor lock-in.

---

Summary: the stack

Component	Role	Execution Model
fluxrig Rack	The Engine	Main Process
NATS	The Wire	Embedded Mesh Node
CBOR	The Format	High-Fidelity Binary Encoding
OpenTelemetry	The Watchtower	Compiled into Binary (Go SDK)
Bento	Cloud Connectors	Compiled into Binary (Go Module)
ClickHouse / DuckDB	Deep Storage	External DB / Embedded DB
ARC	Unified Reporting	External Enterprise Layer [Roadmap]
Temporal	Durable Workflow	External Service [Roadmap]
Wasm	Sandboxed Logic	Polyglot Plugins [Roadmap]