AppConfigLive
Live-ops feature flags and remote config from AWS AppConfig

Overview

AWS AppConfig stores feature flags and freeform configuration (JSON, YAML, text) per application, environment and configuration profile, and rolls changes out with deployment strategies and automatic rollback. AppConfigLive brings that into Unreal Engine 4.27 and 5.8.

• Sessions: Start Configuration Session opens an AppConfig Data session and keeps it current with background polling that honours the interval AppConfig asks for.
• Feature flags: Get Flag Enabled, typed attribute getters, enabled-flag lists and the names of the flags that changed in every update.
• Remote config: typed values by path (shop.featured[0].sku), whole sections into Blueprint structs.
• Offline: snapshots on disk restored at start-up, shipped fallbacks, local overrides for QA menus and kill switches.
• Live-ops tools: list, read and create applications, environments, profiles and hosted versions, start / stop / wait for deployments, validate configurations, resolve names to ids.

Requirements

Installation

1. Install AppConfigLive from Fab into your engine, or copy the AppConfigLive folder into your project's Plugins folder.
2. Enable AppConfigLive in Edit > Plugins and restart the editor.
3. Open Project Settings > Plugins > AppConfigLive: set Region, Identity Pool Id and the Application / Environment / Configuration Profile identifiers (names or ids).
4. C++ only: add PublicDependencyModuleNames.Add("AppConfigLive"); to your Build.cs.

Setting up AWS

1. In the AWS AppConfig console create an application (for example MyGame), an environment (Production) and a configuration profile: Feature flag for flags, Freeform for JSON settings.
2. Add flags or a JSON document, save a version and start a deployment (strategy AppConfig.AllAtOnce for instant changes).
3. In Amazon Cognito create an identity pool with guest access (players read configuration before they sign in).
4. Give the pool's player roles read access to the configuration only:

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["appconfig:StartConfigurationSession", "appconfig:GetLatestConfiguration"],
    "Resource": "arn:aws:appconfig:us-east-1:123456789012:application/abc1234/environment/def5678/configuration/ghi9012"
  }]
}

The resource is application/<app id>/environment/<env id>/configuration/<profile id> (ids, not names; Resolve Names To Ids or the console show them). Use * segments to cover several profiles.

Live-ops tools (admin nodes)

The nodes in the Admin group call the AppConfig control plane. Never give them to the player role. Use them from an editor utility or an internal tool signed in with an admin identity, static keys or the default credential chain, with a policy such as:

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": [
      "appconfig:ListApplications", "appconfig:GetApplication", "appconfig:CreateApplication",
      "appconfig:ListEnvironments", "appconfig:GetEnvironment", "appconfig:CreateEnvironment",
      "appconfig:ListConfigurationProfiles", "appconfig:GetConfigurationProfile", "appconfig:CreateConfigurationProfile",
      "appconfig:ListHostedConfigurationVersions", "appconfig:GetHostedConfigurationVersion", "appconfig:CreateHostedConfigurationVersion",
      "appconfig:ListDeploymentStrategies", "appconfig:GetDeploymentStrategy",
      "appconfig:ListDeployments", "appconfig:GetDeployment", "appconfig:StartDeployment", "appconfig:StopDeployment",
      "appconfig:ValidateConfiguration"
    ],
    "Resource": "*"
  }]
}

Environments with CloudWatch alarm monitors also need iam:PassRole for the alarm role.

Quick start

Feature flags in Blueprint

1. In your Game Instance (or the first level's Begin Play) call Get Default Config Session and store the result in a variable Config.
2. Optional: Load Fallback From File with Content/Config/Defaults.json (add the folder to Additional Non-Asset Directories to Package) so the game has values before the first download.
3. Bind On Configuration Changed on Config to refresh your UI and gameplay.
4. Call Start Configuration Session with Session = Config and Start Polling ticked.
5. Anywhere: Get Flag Enabled (double_xp) and Get Flag Attribute As Float (double_xp, multiplier, Default 1.0).

Freeform JSON

For a profile with {"shop": {"discount": 0.2, "featured": [{"sku": "sword_01"}]}}: Get Value Float shop.discount, Get Value String shop.featured[0].sku, or Get Value As Struct shop into your own Blueprint struct.

Publishing a change from a tool

1. Resolve Names To Ids (MyGame, Production, LiveOps).
2. Make Feature Flags Document from an array of flag structs, then Create Hosted Configuration Version with Content Type application/json.
3. Start Deployment with the new Version Number (as text) and strategy AppConfig.AllAtOnce, then Wait For Deployment.

How it works

• Polling. Each session holds an AppConfig Data token. Every poll calls GetLatestConfiguration; AppConfig answers with an empty body when nothing changed, and the session keeps its previous content. Polls never come sooner than the larger of your Poll Interval, the Required Minimum Poll Interval and the interval AppConfig sends back. Expired tokens (24 h) are renewed automatically. Failures back off up to 10 minutes and fire On Error; the last good configuration stays in effect.
• Sources. Get Source tells where the data came from: Live (AppConfig, this run), Snapshot (saved by an earlier run), Fallback (shipped defaults). A fallback is replaced by a snapshot or live data; a snapshot only by live data.
• Snapshots. With the default cache policy Save And Restore Snapshot every new live configuration is written to Saved/AppConfigLive/<app>_<env>_<profile>.json and restored when the session starts, so players have the last known values offline and on the first frame.
• Overrides. Set Flag Override and Set Value Override sit on top of every configuration until Clear Overrides. Get Raw Text always returns the unmodified document.
• Changes. On Configuration Changed carries the changed, added and removed flag names (flag profiles) or the changed top-level keys (freeform JSON).
• Lifetime. Sessions created with a world context belong to the game instance and stop when it shuts down (end of Play In Editor). Without a game instance (editor utilities) keep the session in a variable.
• YAML / text. Non-JSON profiles are available through Get Raw Text / Get Raw Bytes; the flag and value getters return their defaults.

Node reference

86 Blueprint nodes. Latent nodes run in the background, can be stopped with Cancel on their return value and fire exactly one final pin on the game thread. Session nodes are called on an AppConfigLive Session object.

Config and identity

Sessions and polling

Document

Feature flags

Freeform values

Overrides and offline

Admin: applications, environments, profiles (latent)

Admin: deployments (latent unless noted)

Credentials

C++ API

// Build.cs: PublicDependencyModuleNames.Add("AppConfigLive");
#include "AppConfigLiveLibrary.h"
#include "AppConfigLiveSession.h"

UAppConfigLiveSession* Config = UAppConfigLiveLibrary::GetDefaultConfigSession(this);
Config->OnConfigurationChanged.AddDynamic(this, &UMyGameInstance::HandleConfigChanged);
Config->Fetch([](bool bOk, const FAppConfigLiveFetchResult& Result, const FAppConfigLiveError& Error)
{
    // game thread
});
Config->StartPolling(0.f);

const bool bDoubleXp = Config->GetFlagEnabled(TEXT("double_xp"), false);
const float Discount = Config->GetValueFloat(TEXT("shop.discount"), 0.f);

The latent node classes (UAppConfigLiveStartSessionAction and the others) can be created from C++ through their static factory functions; bind the delegates, then call Activate().

Types

Settings

Project Settings > Plugins > AppConfigLive (saved to DefaultGame.ini).

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Includes the AWS SDK for C++ and the AWS Common Runtime (Apache License 2.0). Built for Unreal Engine 4.27 and 5.8.