Get started
← Blog

The open-source ConfigCat alternative: flags in git, not a dashboard

Oct 17, 2026

dif is the open-source ConfigCat alternative that keeps every flag as a Markdown file in your repo instead of a row in a hosted dashboard. ConfigCat is a simple, affordable SaaS: you flip a flag in its dashboard and the change reaches your app through a config JSON, no deploy required. dif takes the opposite bet. A flag is a file next to the code it gates, reviewed in a pull request, and the change only ships when that PR merges.

Both tools are aimed at teams who find LaunchDarkly too heavy. ConfigCat keeps the dashboard but makes it cheap. dif removes the dashboard. This post covers what changes when a flag stops living in a hosted UI and starts living in your repo, where ConfigCat still wins, and what porting a flag actually looks like.

Key Takeaways

  • dif stores every flag as a Markdown file in your repo. ConfigCat stores flags in its hosted dashboard and delivers them to SDKs as a config JSON over a CDN.
  • ConfigCat’s Forever Free plan caps at 10 feature flags; Pro is $110/month for 100 flags; Smart is $325/month for unlimited flags capped at 10 products.
  • dif Cloud is $50/month flat for 1M events with unlimited seats and no cap on flag count.
  • ConfigCat ships 30+ official SDKs, including Unity, Unreal Engine, and Rust. dif’s SDK covers JavaScript and TypeScript, with React and Svelte adapters.
  • dif emits a context.json a coding agent reads on session start. ConfigCat’s dashboard has no equivalent export for an agent working in the repo.

Why teams look for a ConfigCat alternative

ConfigCat is a reasonable tool. Teams go looking for something else for a few specific reasons.

The flag isn’t reviewed. A rollout percentage changed in ConfigCat’s dashboard takes effect the moment someone saves it. Nothing requires a second pair of eyes, and nothing records the reasoning next to the code it affects.

Flag count is the pricing lever. The Forever Free plan stops at 10 feature flags. Pro doubles the price to $110/month for 100. Needing an eleventh flag on the free tier, or a hundred-and-first on Pro, is what forces the upgrade, not usage or seats.

Drift between the dashboard and the repo. The targeting rule lives in ConfigCat; the if statement that reads it lives in your source. A rule can keep gating a code path long after the branch behind it is gone, because nothing connects the two.

Nothing fails the build. A misspelled flag key, or a targeting rule that references a segment nobody maintains anymore, surfaces at runtime, not in CI. dif validate catches that class of error before it ships.

dif as the alternative in one paragraph

dif takes the flag out of the dashboard and makes it a file. dif init scaffolds a dif/ directory next to your source. Each flag is a Markdown file: YAML frontmatter for the owner, audience, variants, and weights, and prose below for the brief and the decision. dif validate runs in CI. dif build compiles the active files into a typed client your app imports directly. The flag ships with the code that uses it, in the same pull request. See feature flags in your repo for the full model.

The model, side by side

ConfigCat is a hosted service. Your dashboard changes write to ConfigCat’s backend, and each SDK polls the ConfigCat CDN for a new config JSON on an interval (60 seconds by default), or waits for a webhook-triggered refresh. The SDK then evaluates targeting rules against that fetched config locally, so user data never leaves your system even though the rules themselves come from ConfigCat’s CDN.

dif is a file format. The flag is a Markdown file in dif/flags/active/. Changing a rollout percentage is editing a number in that file and merging. dif build compiles the active files into a generated TypeScript client, and the SDK computes each user’s variant locally by hashing their ID. There is no config fetch, because there is nothing external to fetch: the rules are already compiled into the client your build shipped.

ConfigCat’s model is built for an operator who wants a rollout percentage to change in production without waiting on a deploy. dif’s model is built for a codebase where the rule and the call site belong in the same code review, and the deploy is the mechanism, not an inconvenience.

Feature comparison

DimensiondifConfigCat
Where flags liveMarkdown files in your repoConfigCat's hosted dashboard, delivered as a config JSON
Change a flagEdit the file, open a PR, merge, deployChange in the dashboard; SDKs pick it up on the next poll or webhook
Review before it shipsYes, pull request requiredNo; a dashboard save is live immediately
License / hostingOpen source (MIT); nothing to self-host for the core workflowClosed-source SaaS; no self-hosted option
Flag count limitNone10 on Free, 100 on Pro ($110/mo), unlimited on Smart ($325/mo)
Language SDK breadthJavaScript and TypeScript, with React and Svelte adapters30+ official SDKs, including Unity, Unreal Engine, Rust, and Flutter
CI validationdif validate checks weights, owners, and collisions before mergeNone; a broken rule surfaces at runtime
Agent-readable stateYes (context.json)No; state lives behind the dashboard and the management API
Cloud entry price$50/mo, 1M events, unlimited seats and flags$0/mo Free (10 flags), $110/mo Pro (100 flags)

Where ConfigCat wins

ConfigCat earns real rows here.

Language and platform breadth. 30+ official SDKs cover backends dif doesn’t touch (Java, Go, PHP, Ruby, .NET, Python) plus Unity, Unreal Engine, and native mobile. A polyglot stack with a Unity client is a ConfigCat strength dif does not match.

An operator dashboard. A support engineer or a growth PM can flip a kill switch from a UI with no pull request in the way. For a team with no engineer on call at 2 a.m., not waiting on a PR to merge is worth the tradeoff.

Nothing to build or compile. ConfigCat’s SDKs fetch a live config; there is no dif build step to run before a flag takes effect. A team that wants the change live the second someone saves it gets that here, and gives up the pull-request review to have it.

Where dif wins

The flag is the file. dif/flags/active/new-checkout.md is the whole thing: opening it answers “why does this exist” without logging into a dashboard.

---
id: new-checkout
status: active
owner: sam@acme.com
surface: checkout
audience:
  include:
    - device_type: [mobile, tablet]
variants:
  - id: "off"
    weight: 90
  - id: "on"
    weight: 10
metrics:
  primary: completed_checkout
  guardrails:
    - refund_rate
---

## Brief

Ramping to 25% once the guardrails hold for a week. Owner is Sam.

Pull-request review is the approval flow. dif validate runs in CI, so a broken flag fails the pull request the same way a broken build does:

$ dif validate

E004  dif/flags/active/new-checkout.md
      Weights do not sum to 100 (got 95).

E007  dif/experiments/active/checkout-copy-v2.md
      Collides with checkout-copy-v1 on surface "checkout".
      Add an exclusion_group or disjoint audiences.

2 errors, 0 warnings.

No flag-count ceiling. dif Cloud’s $50/month Pro tier is priced on events, not on how many flags you have open. ConfigCat’s Free and Pro tiers gate the number of flags directly, so a team adding an eleventh flag on Free upgrades for a limit that has nothing to do with traffic.

Agent-readable state through context.json. dif build writes every active flag and each surface’s latest learning to a file a coding agent reads on session start. See context.json explained for how an agent uses it to avoid breaking a live flag.

Who should switch, and who should stay on ConfigCat

Stay on ConfigCat if any of these are true:

  • Your stack spans languages dif doesn’t cover (Go, Java, PHP, Ruby, .NET) or you ship a Unity or Unreal Engine client that needs a flag SDK.
  • A non-engineering owner needs to flip a flag from a dashboard with no pull request in the loop.
  • You want a flag change to take effect the instant it’s saved, with no build step first.

Switch to dif if any of these are true:

  • The flag is a code-review artifact. A rollout change should get a PR review next to the call site it gates.
  • Flag count is pushing you up ConfigCat’s pricing tiers and your stack is JavaScript or TypeScript.
  • A coding agent works in your repo. Claude Code, Cursor, or any agent reads context.json on session start, so it never deletes a branch behind a live flag.

What migration looks like

Migration is per-flag; the format is small enough that porting by hand usually beats automation.

Install the CLI and scaffold the workspace:

npm install -g @dif.sh/cli
dif init

Pick one active ConfigCat setting. Recreate it as a Markdown file in dif/flags/active/. Map the fields:

  • ConfigCat’s Key becomes dif’s id
  • The served value and percentage options become variants and weights
  • Targeting rules become dif’s audience.include and audience.exclude blocks

A ConfigCat call in TypeScript:

import * as configcat from "configcat-js";

const client = configcat.getClient("YOUR-SDK-KEY");
const isOn = await client.getValueAsync("newCheckout", false);

if (isOn) {
  return <NewCheckout />;
}

The dif equivalent:

import "./dif/generated/client";
import { dif } from "@dif.sh/sdk";

if (dif("new-checkout") === "on") {
  return <NewCheckout />;
}
return <LegacyCheckout />;

Run dif validate in CI. Fix what it flags, merge the pull request, port one flag a week, and remove the ConfigCat SDK call site as you go. The feature flags in git post covers the day-to-day workflow once flags live in the repo.

FAQ

Is dif a ConfigCat alternative? Yes. Both handle feature flags and percentage rollouts. The difference is where the flag lives: dif stores each flag as a Markdown file in your repo, reviewed in a pull request. ConfigCat stores flags in its hosted dashboard and delivers them to SDKs as a config JSON.

Can I self-host dif instead of ConfigCat? There’s nothing to self-host for dif’s core workflow. The CLI and SDK are MIT licensed and run entirely from your repo, no server or database required. ConfigCat has no self-hosted option; it’s SaaS only.

How does dif’s SDK coverage compare to ConfigCat’s? ConfigCat wins on breadth: 30+ official SDKs across backend languages, mobile, and game engines like Unity and Unreal Engine. dif’s SDK is JavaScript and TypeScript, with React and Svelte adapters. For a JS or TS stack, dif fits; for a polyglot or game-client stack, ConfigCat fits.

What is the cheapest feature-flag tool, dif or ConfigCat? ConfigCat’s Forever Free plan is $0/month but caps at 10 feature flags. dif’s CLI and SDK are free with no flag-count limit at all, since there’s no hosted service gating them. For managed analytics, dif Cloud is $50/month flat for 1M events; ConfigCat’s Pro tier is $110/month for 100 flags (see ConfigCat pricing).

Does dif have a dashboard like ConfigCat? No. The flag is a file in your repo, and changing it is a pull request. ls dif/flags/active/ is the state of everything in flight.

What is the tradeoff with dif? A flag change ships with a merge and a deploy, not a dashboard save. If your build takes ten minutes, your worst-case kill is ten minutes. For a flag a non-engineer needs to flip without a PR, or a Unity client ConfigCat already supports, dif isn’t the right fit for that one flag.

Try dif as your ConfigCat alternative

The right ConfigCat alternative depends on whether the flag belongs in code review or in a dashboard. If your stack is JavaScript or TypeScript, flag count is pushing you up ConfigCat’s pricing tiers, and you’d rather the change ship with a pull request than a dashboard save, dif is the shorter path. If you need broad SDK coverage across languages and game engines, or a non-engineer needs to flip flags with no PR in the loop, stay on ConfigCat.

Install the CLI and scaffold a project. No account, no API key, no dashboard.

npm install -g @dif.sh/cli
dif init

dif init writes the dif/ directory, a generated TypeScript client, and the managed agent guidance blocks. From there, dif new drafts a flag, dif validate runs in CI, and dif build compiles the active files. The docs cover the CLI and SDK in full.