Tech Insights
Cloudflare’s Flagship Rust SDK Moves Feature Flags Closer to the Service
Cloudflare has added an official Rust SDK to Flagship, giving async Rust services OpenFeature-compatible feature evaluation with both remote and local modes.
Feature flags are easy to describe and surprisingly easy to get wrong. A service asks whether a feature is enabled, the flag platform applies targeting rules, and the application chooses a path. The awkward part is what happens between those steps: every remote evaluation can add a network dependency, while every local cache introduces questions about freshness, rollout changes, and operational visibility.
Cloudflare has now added an official Rust SDK to Flagship. In its November 10, 2026 changelog entry, Cloudflare says the SDK lets async Rust server applications evaluate flags through OpenFeature with the same targeting rules and percentage rollouts available elsewhere in Flagship. The Flagship SDK documentation lists Rust alongside the existing TypeScript, Python, and Go options.
The meaningful change is not just another language package. Rust services can now choose between a straightforward HTTP path and an in-process evaluation path, which makes feature-flag behavior part of the service’s latency and resilience design rather than a separate afterthought.
Why the evaluation location matters
In remote evaluation, a service sends a flag name and user or request context to a feature-flag service, then waits for the answer. That keeps the decision current and centralizes the rules, but it also adds a network hop to the request path. A temporary outage, a slow connection, or a badly placed dependency can make a small product decision influence the availability of a larger service.
Local evaluation takes the opposite approach. The SDK downloads the flag definitions and evaluates them inside the application process. Cloudflare says its Rust provider supports remote, cached, and local evaluation, so teams can choose a model that matches the workload instead of treating every flag check as an HTTP call.
That distinction is useful for Rust services that already care about predictable latency, explicit concurrency, and failure behavior. A checkout service, API gateway, or background worker can keep the feature decision close to the code that consumes it. The trade-off is that the service now needs a strategy for refreshing definitions and handling a stale or unavailable configuration.
What the Rust SDK adds
Cloudflare’s Rust package is cloudflare-flagship. The documented setup uses the async OpenFeature server SDK and a Tokio runtime. A typical service can create a Flagship provider, register it with OpenFeature, and ask for a typed value using a targeting key such as a user, tenant, or request identifier.
The provider supports structured evaluation context, which is more useful than passing a single string when rollout rules depend on several attributes. A team might target a feature by tenant tier, region, account age, or an experiment cohort. Structured context lets the service express those values without flattening the decision into ad hoc strings.
Cloudflare also documents optional response caching plus logging and telemetry hooks. Those hooks matter operationally because a flag system is not only a control plane. When a rollout behaves unexpectedly, teams need to know which value was resolved, which context was used, and whether the decision came from a remote request or local state.
A concrete rollout example
Consider an async Rust API that is introducing a new checkout path. The team wants to start with five percent of users, expand to twenty-five percent if error rates remain stable, and return to the old path quickly if the new flow fails.
With Flagship, the rollout rule can remain in the feature-flag control plane while the service asks OpenFeature for a Boolean value. The targeting key keeps a user consistently in the same cohort, avoiding a request-by-request flip between the old and new behavior. The team can change the percentage without redeploying the service, and the application code can keep a simple branch around the flag.
For a latency-sensitive endpoint, the Rust provider can use local evaluation after it has synchronized the definitions. The checkout service does not need a flag request for every page view or API call. For an administrative control plane where the latest decision matters more than the extra network hop, the team might prefer HTTP evaluation or a shorter refresh policy.
What is different from a generic feature-flag client
The SDK is designed around OpenFeature, the CNCF standard for a vendor-neutral feature-flag API. That gives the application a stable interface for asking whether a flag is enabled or which variant should be used. It also means the flag provider is separate from the application’s decision code.
In practical terms, the service can keep its feature checks expressed through OpenFeature while the provider handles Flagship transport and evaluation behavior. That separation may reduce the cost of changing providers later, although portability is never automatic: targeting semantics, flag types, rollout consistency, hooks, and operational workflows still need to be compared.
The trade-offs teams should not skip
Local evaluation is fast, but it is not magic. A service may continue using an older flag definition until its refresh completes. That can be acceptable for a UI experiment and unacceptable for a control that disables a risky operation. Teams should classify flags by consequence and define a refresh, fallback, and kill-switch strategy accordingly.
Remote evaluation keeps the decision centralized but makes the flag service part of the dependency graph. Timeouts, retries, and default values need to be deliberate. A default that silently enables a new code path can be very different from a default that keeps the old path active.
There are also language and runtime requirements. Cloudflare says the SDK requires Rust 1.88 or later and a Tokio runtime. The application must manage provider initialization and shutdown, authentication for server-side use, and the amount of flag data held in memory. Those are normal concerns for a service library, but they should be part of the design review rather than hidden in a helper module.
Where the release fits
The Rust SDK broadens Flagship’s reach into services that do not run JavaScript or Python at the edge. That matters because feature flags are most valuable when they are available at the point where teams need a safe, reversible change: a high-throughput API, a queue consumer, a control-plane service, or a long-running worker.
Cloudflare’s release gives Rust teams more control over where flag decisions happen. The best choice will depend on the meaning of the flag, the acceptable staleness window, the service’s latency budget, and how much observability the team needs. The release is useful precisely because it does not force one answer: it makes remote and in-process evaluation available behind the same application-facing model.
This article is a general information summary based on the cited public sources. It is not legal, cybersecurity, or compliance advice.