Kix is a Kubernetes compiler.

It turns your cluster definition into a verifiable cluster artifact, so teams can understand, change, and operate Kubernetes with confidence.

Join the preview

What compile-time Kubernetes changes.

Feedback moves earlier, deployments become inspectable, and operations are driven by the same evaluated cluster model.

Pre-commit feedback

Broken dependencies and policy violations are caught before you commit.

Checked deploys

Preview the evaluated result, then apply it in dependency order.

Operational tooling

Diff, graph, evidence, drift, deploy order, rollback.

A quick example.

A developer renames the Postgres instance from postgres to pg and misses one reference. The cluster would compile, deploy, and only fail when the app first tries to read the database. Kix fails the build at commit time, with the fix in the error.

cluster.nix

{
  kix.instances = {
    pg = {
      package = pkgs.cloudnative-pg-cluster;
      namespace = "data";
    };

    api = {
      package = acmePackages.api;
      namespace = "acme-prod";
      deps.database = ref "postgres";
    };
  };
}

$ kix check prod-eu

error: api.deps.database
  references unknown instance "postgres"
  did you mean "pg"?

prod-eu: 1 error
build aborted, nothing deployed

You can also diff against the deployed cluster, graph dependencies, deploy in order, roll back, and export plain Kubernetes manifests.

Join the preview

One compile, inspectable results.

Every compile produces concrete information you can inspect before the cluster changes.

Change preview What Kix will apply before it touches the cluster.
Dependency graph The cluster as a system of edges, ready to inspect.
Structural diff Exactly what changes from one compile to the next.
SARIF report Policy and check results in a standard finding format.
SBOM / provenance Build evidence for every artifact you ship.
Rollback history Concrete references to recover from a bad change.

Evaluate the cluster as one system.

A Kubernetes cluster is a system of relationships. Kix evaluates that system as one artifact before deployment, then emits standard resources for the delivery process you choose.

Verifiable cluster artifact

The output is concrete: checked, diffed, reviewed, deployed, rolled back, and tied to evidence.

Broken edges caught early

Selectors, routes, ports, RBAC, storage, TLS, and monitoring wiring are checked before the cluster is touched.

Compliance as build output

Produce SARIF, SBOM, provenance, attestations, activation hashes, and audit evidence from the same evaluation.

Dependency-aware operations

Understand blast radius, deploy in order, reason about drift, and roll back with the graph in view.

Whole-cluster automation follows from the artifact model.

Because Kix evaluates the cluster as one artifact, it can derive work teams usually maintain by hand: network policy, RBAC, monitoring wiring, ingress, ordering, repeated platform rules, and environment-specific variation.

Start small. Keep your Kubernetes.

Kix emits standard Kubernetes resources and can coexist with Helm, Argo, Flux, and existing CI. The benefits compound as more of the cluster moves into native Kix packages.

Run the full demo cluster

Compile a disposable cluster, inspect the graph and reports, deploy it, make a change, and roll back.

Choose a controlled boundary

Start with a new cluster, selected subsystem, or imported resources that match what already runs.

Move structure into packages

Native packages expose richer structure, which unlocks stronger checks, generated wiring, and better operational tooling.

Created from real Kubernetes operations.

Kix comes from operating production Kubernetes infrastructure. The team behind it runs Lithus, a managed private-cloud provider operating dedicated bare-metal Kubernetes clusters in Germany, with migrations, observability, backups, SRE ownership, and incident response included.

Kix is the tooling we wanted for that work: cluster state that is testable, repeatable, explainable, and safer to change.

Production clusters Managed infrastructure for real customers.
Pager ownership The same team handles incidents and recovery.
Stateful systems Databases, storage, networking, and observability.
Migration work Built around messy existing infrastructure, not demos.

Know what will happen before you change your cluster.

Kix turns your cluster definition into a verifiable artifact, so platform teams can understand, change, and operate Kubernetes with confidence.

Join the preview