hyphen
Hyphen Toggle

Ship it now. Release it later.

Toggle decouples deploying from releasing. Merge the code dark, turn it on for the people you choose, and change your mind from the dashboard without shipping again.

Get startedView docs
OpenFeature · 99.95% SLA · edge cached · self-hostable
checkout-experience
Storefront · string · 3 targets
on
Targets, in order
  1. 1Segment in beta-testersexpress
  2. 2user.plan == enterpriseclassic
  3. 3application == checkout-webclassic
  4. –Defaultlegacy
[email protected]beta-testers
express
How it works

Four moves from merged to released. None of them a deploy.

  1. 01

    Grab your public key

    Every project has one. It scopes the SDK to your flags and nothing else, so it is safe to ship in a client bundle.

  2. 02

    Create the flag

    Give it a key, a type, and a default. Booleans for on and off; strings, numbers, and JSON when a feature needs more than two states.

  3. 03

    Add your targets

    Rules are matched top down, and the first one that fits returns its value. Point them at a saved segment when the same audience shows up again.

  4. 04

    Evaluate in code

    One call with your context returns the value for that user. Change the rule in the dashboard and the answer changes, with no deploy.

Targeting

Describe the audience once. Point every flag at it.

A segment is a saved set of rules: email, id, plan, application, or anything else on your context. Change who is in it and every flag targeting it changes with it.

beta-testers
Reusable audience · Storefront
in use by 4 flags
Rules, in order
  1. 1user.emailcontains@acme.com
  2. 2user.idindana, sam, lee
  3. 3application==checkout-web

Matched top down. The first rule that fits puts the context in the segment.

Targeted by
checkout-experienceexpress-paynew-navpricing-v3
Read about segments
SDKs

Speaks your language. All of them, the same way.

Every SDK is an OpenFeature provider, so the call is the same shape wherever you make it: a flag key, a fallback, and your context.

Toggle setup guide
import { OpenFeature } from '@openfeature/server-sdk';import {  HyphenProvider,  HyphenProviderOptions}from '@hyphen/openfeature-server-provider';
// Register your feature flag providerconst publicKey = "your-public-key-here";const options: HyphenProviderOptions = {  application: 'your-application-name',  environment: 'production',};await OpenFeature.setProviderAndWait(new HyphenProvider(publicKey, options));
// Create evaluation context with user dataconst user = {  id: 'user-123',  email: '[email protected]',  name: 'John Doe'};OpenFeature.setContext({ targetingKey: user.id, user: user});
// Create a new clientconst client = OpenFeature.getClient();
// Evaluate your feature flagconst flagDetails = await client.getBooleanDetails('feature-flag-key', false);console.log(flagDetails.value); // true or false
Capabilities

Everything a flag service owes you, including a way out of it.

Multivariate values, edge caching, real-time updates, and the tooling to retire a flag once it has done its job.

  • Multivariate flags

    From simple true-false scenarios to more complex use cases requiring multi-variate flags such as strings, numbers, and JSON objects.

  • Cached at the edge

    Toggle’s CDN caches feature flag evaluations at the edge, ensuring low latency and high availability.

  • Real-time updates

    Our architecture ensures your applications receive flag changes instantly, without the need to redeploy or restart your application.

  • SDKs for all platforms

    Hyphen Toggle SDKs make it easy to integrate feature flags into your applications, no matter what language or platform you’re using.

  • Self-hosted with Horizon

    Run evaluation on your own infrastructure for redundancy, caching, and reduced usage costs.

    About Horizon

  • Test in production

    Ensure your features work as expected in a production environment by testing them on a subset of users before enabling them for everyone.

  • Entitlement management

    Feature flags paired with advanced targeting are the ideal way to manage entitlements like beta access or administrative permissions.

  • Tech-debt mitigation

    As feature flags become stale over time, Toggle helps you identify and remove them, reducing the risk of tech debt.

Coverage

One flag, evaluated everywhere. Consistently, and fast.

Every platform

OpenFeature providers for Go, Python, .NET, and JavaScript on the server, the web, and React, so one flag reads the same everywhere.

Read the quickstart

Every environment

Development, staging, and production each evaluate the same flag against their own targets, so a rollout in one is not a rollout in all.

Pair it with ENV

Every millisecond

Evaluations are cached at the edge, and Horizon runs them inside your own network when even that is further than you want to go.

Run it yourself

Frequently Asked Questions

How do I implement feature flags without adding complexity to my codebase?

Add feature flags with just a few lines of code using Hyphen Toggle SDKs for JavaScript, React, Go, Python, .NET, and other major platforms. Flags support simple boolean toggles and multivariate values (strings, numbers, JSON), and changes take effect in real time without redeploying. When flags become stale, Toggle helps you identify and remove them to prevent tech debt.

What is the best feature flag service for fast-growing engineering teams?

Hyphen Toggle is built for teams that need enterprise-grade feature management without the overhead. It's OpenFeature compatible, backed by a 99.95% SLA, and cached at the edge for low-latency evaluations. You can run locally with Horizon for even faster performance and full redundancy. Flexible targeting lets you roll out features by user attributes, location, environment, or any custom criteria.

How do I safely test features in production before rolling them out to all users?

Toggle lets you deploy code in an "off" state and then target specific users or segments for testing before a full rollout. Use flexible targeting rules with AND/OR logic to control exactly who sees what. This decouples deployments from releases. You can ship code to production anytime and toggle features on when they're ready, reducing deployment risk to near zero.

How do I use feature flags for entitlement management and beta access?

Toggle's advanced targeting capabilities make it ideal for managing entitlements like beta access, admin features, or tiered product plans. Define targeting rules based on user attributes, subscription level, or any custom context, and Toggle evaluates them in real time. Full audit logs track every change to every flag, maintaining compliance with your organization's policies.

Can I self-host feature flag evaluation for lower latency and redundancy?

Yes. Hyphen Horizon lets you run feature flag evaluation on your own infrastructure or at the edge. Self-hosted instances stay operational even if the primary service is unavailable, giving you fault tolerance and sub-millisecond evaluation times. This is ideal for latency-sensitive applications or teams that need to keep flag evaluation within their own network.

Deploy on Tuesday. Release on Thursday.

Install a provider, create a flag, and ship the code with it turned off. Who sees it, and when, stops being a deployment question.

Get startedView docs