Kubernetes-native Feature Flags

Feature flags that
live in your cluster

Define feature flags as CRDs. Deliver them via environment variables, ConfigMaps, or a real-time sidecar API. No external dependencies.

Get Started View on GitHub
featureflag.yaml 
apiVersion: vexil.io/v1alpha1
kind: FeatureFlag
metadata:
  name: dark-mode
spec:
  type: boolean
  defaultValue: "false"
  delivery:
    envVar:
      name: FEATURE_DARK_MODE
      selector:
        matchLabels:
          app: frontend

Everything you need

A complete platform for managing feature flags at scale across your Kubernetes infrastructure.

Kubernetes-Native

Feature flags as CRDs. No external services. Fully integrated with RBAC, namespaces, and the Kubernetes API.

Three Delivery Methods

Environment variables for simplicity, ConfigMaps for hot-reload, or sidecar API with real-time SSE streaming.

Progressive Rollouts

Canary and linear rollout strategies with configurable steps. Safely deploy flag changes to a percentage of workloads.

Multi-Cluster

Manage flags across multiple Kubernetes clusters from a single dashboard. Auto-discover workloads and their configuration.

Targeting Rules

Deliver different values based on namespace, labels, annotations, or workload name. Multiple operators including regex matching.

RBAC & Audit

Admin, editor, and viewer roles. Full audit trail of every flag change with actor, timestamp, and diff.

A dashboard you'll actually use

Manage flags, discover workloads, and browse audit logs from a modern web portal.

vexil.example.com

Feature Flags

Manage feature flags across your clusters

Name Type Value Phase Targeted
dark-mode default
boolean true Active 3 workloads
api-rate-limit default
integer 100 Active 1 workload
new-checkout-flow default
boolean false RollingOut 2 workloads
banner-text staging
string Welcome Active 4 workloads
maintenance-mode prod
boolean false Disabled 0 workloads

How it works

Three components working together to deliver feature flags at the Kubernetes layer.

1

Define

Create a FeatureFlag CRD with your flag type, value, targeting rules, and delivery method.

kind: FeatureFlag
spec:
  type: boolean
  defaultValue: "false"
  delivery:
    envVar:
      selector:
        matchLabels:
          app: my-app
2

Reconcile

The operator watches for flag changes and injects values into matching workloads automatically.

Operator detects flag change
Finds matching workloads
Injects flag values
3

Consume

Read flags from your application using environment variables or one of the client SDKs.

// Go
client, _ := vexil.New(
  vexil.WithEnvProvider(),
)
darkMode := client.Bool(
  "dark-mode", false,
)

// or just read the env var
os.Getenv("FEATURE_DARK_MODE")

Client SDKs

Read flags from any language. Same API everywhere.

Go 
client, _ := vexil.New(
  vexil.WithSidecarProvider("localhost:8514"),
)
dark := client.Bool("dark-mode", false)
limit := client.Int("rate-limit", 100)
Python 
client = Client(provider="env")

dark = client.bool("dark-mode", default=False)
limit = client.int("rate-limit", default=100)
Node.js 
const client = new Client({ provider: 'env' });

const dark = await client.bool('dark-mode');
const limit = await client.int('rate-limit', 100);
C# / .NET 
using var client = new VexilClient(
  new EnvProvider()
);
var dark = client.Bool("dark-mode");
var limit = client.Int("rate-limit", 100);

Ready to start?

Deploy Vexil to your cluster in under 5 minutes.

$ helm install vexil deploy/helm/vexil \
    -n vexil-system --create-namespace
Read the Docs Star on GitHub