Compile scattered configuration into one validated model — then resolve an exact, reproducible config for any product or deployment.

Decentralized CUE configuration chunks — your shared, typed building blocks.

Merge and validate into the 150% model (a typed graph); emit a hash-addressable Compiled Model Package (CMP).

Apply late-binding selections to resolve the strict 100% model; export generated C++ headers, build flags, manifests, and a software BOM.

The runtime delivers resolved config to a live system — deterministic delta-first sync, a layered store, commit/rollback, and an event bus.

Deterministic by construction

Outputs are canonicalized and hashed. The same inputs always produce the same bytes — and the same hashes.

Scenario packs

Reusable product families for robotics, industrial automation and building systems — a starting point, not a blank page.

Bazel-only, hermetic build

One command, fully sandboxed and reproducible. No surprise dependencies leaking in from your host.

Staged pipeline

Compiler → interpreter → runtime, driven by the one-shot cfx CLI, with a first-party C++ SDK and ROS 2 adapters for embedding in real systems.

Integrate from anywhere

Resolved configuration ships as plain files, a stable CLI (JSON in/out), and a versioned C ABI — read it from any language, subprocess the CLI, or bind the ABI. First-party C++ and ROS 2 SDKs included.

Auditable outputs

Resolved models, generated headers, build flags, manifests, and a first-party software BOM — all inspectable.

Constraints you can question

cfx options lists what a deployment may still choose. cfx explain names the rule behind a refused choice in the author's own words — the requirement and the entries it accepts, or the binding that fixed a value.

Typed catalogues and bindings

Declare a typed table once, as data; a binding is one shared choice from it per deployment. Components declare what they requires and may narrow it to what they accepts — two components naming the same binding receive the same entry by construction, and an empty intersection is refused at compile time.

Environments state only free decisions

The constraints decide the rest, reported as implied: choices. One manifest resolves every environment (cfx resolve --manifest … --all), resolved_output_hash separates a real configuration change from an unrelated model edit, and cfx diff exits non-zero exactly when a running service would receive different values.

Compose across repositories

compile-object compiles one unit into a content-addressed object against the interfaces it depends on, and link assembles objects into the same package the one-shot compiler produces. A lockfile pins the object hashes an integration expects, and unchanged units are reused byte for byte.

Signed releases

Release binaries are cryptographically signed, so you can verify exactly what you're running.

Requirement traceability

Behavior maps back to tracked requirements, so your guarantees are auditable — not just asserted.

Software product line — a family of related systems built from shared, configurable building blocks.

The superset model containing every option and variant, before any resolution is applied.

The fully resolved configuration for one specific product or deployment.

The typed configuration language used to author and constrain chunks.

Compiled Model Package — the hash-addressable artifact the compiler emits from the validated 150% model.

Compiled Constraint Model — the compiled solver form emitted alongside the CMP, in the package's ccm/ directory: a symbol table plus a reduced ordered binary decision diagram the solver queries to decide which options remain valid.

A typed table of named entries, declared once as data. A binding is one shared choice of an entry from it — chosen per deployment, and explained like any other facet.

Think of one product family — say, a line of pumps — where every unit shares most of its design but differs in a few options: motor size, firmware features, regional settings. A software product line captures all of those choices once, as constraints, instead of forking a config file per variant. ConfigFlux compiles that shared description, then resolves the exact configuration for the specific unit you're building — reproducibly, and with a record of how it got there.

Device fleets

Many units, many firmware and feature combinations, one source of truth.

Industrial automation

Cells and lines configured per site, with an audit trail for each.

Building systems

HVAC and controls tuned per building from shared, validated blocks.

Multi-environment deploys

Dev, staging and production resolved from one model — no drift.