Installation

This page covers getting the cfcore plugin into an Unreal project and building it. It documents cfcore-sdk-ue.

The SDK ships as a source-only Unreal plugin. There is no prebuilt binary in the release package, so every project compiles the module locally on first load. That drives the whole sequence: copy source into Plugins/cfcore, answer the rebuild prompt, enable the plugin, then add cfcore as a module dependency in C++ projects. Blueprint-only projects follow the same path, and the rebuild is not optional for them, so a Blueprint-only team still needs a working C++ toolchain on the machine that opens the project first.

Installing the plugin does not initialize the SDK. FCFCoreModule::StartupModule registers the settings page and nothing else. See Initialization and settings for what happens next.

Prerequisites

Requirement	Where it comes from
A CurseForge for Studios account with your game registered	The Developer Portal at console.curseforge.com. See Setting up your game
Game ID (int64) and game API key (FString)	Issued per game in the Developer Portal. Set as gameId and apiKey on FCFCoreSettings, or on the CFCore page under Project Settings > Plugins
A C++ toolchain for your platform	Your own machine. The release ships Source/ with no compiled module
Write access to your project's Plugins/ directory	Local

The package contains cfcore.uplugin, Source/, Resources/ (Icon128.png only), docs/, licenses/, LICENSE and README.md. There is no Binaries/ or Intermediate/. If you received a package with Binaries/, it was built against one specific engine version and toolchain: treat source as the distribution format.

note

Premium mods, subscriptions and authentication providers are enabled per game in the Developer Portal, not in the plugin. For those, contact cfforstudios@overwolf.com.

Step 1: extract into Plugins/cfcore

1. Download the release package for the SDK version you intend to ship.
2. Extract the contents of the cfcore-sdk-ue folder, not the folder itself, into Plugins/cfcore in your game project.
3. Confirm the result is Plugins/cfcore/cfcore.uplugin, one level down, not Plugins/cfcore-sdk-ue/cfcore/cfcore.uplugin.
4. Leave the folder named cfcore.

danger

Do not rename the plugin folder or the .uplugin file. The plugin resolves its own descriptor with IPluginManager::FindPlugin(UE_PLUGIN_NAME) and calls GetDescriptor() on the result with no null check (Bootstrap::GetPluginVersion in Private/bootstrap.cpp). A descriptor that cannot be found is a null dereference during setup, not a logged warning.

A git submodule at Plugins\cfcore is a supported layout for the same result.

Step 2: answer the rebuild prompt

1. Reopen your project after extraction.
2. The editor shows a Missing <ProjectName> Modules dialog: "The following modules are missing or built with a different engine version:", listing cfcore, then "Would you like to rebuild them now?".
3. Click Yes. Unreal runs UnrealBuildTool, which runs UnrealHeaderTool over the plugin's UCLASS, USTRUCT and UENUM declarations, then compiles the module.
4. The project opens once the build succeeds.

note

The same dialog reappears after any engine upgrade, because the wording covers both "missing" and "built with a different engine version". Budget time for the header-tool pass: the plugin's public API is spread over a large number of headers, most of which carry a generated reflection header.

Step 3: enable the plugin

1. Open Edit > Plugins.
2. Search for cfcore. The descriptor sets Category to Other, so it appears under Project > Other, not under a modding or online category.
3. Tick Enabled.
4. Restart the editor when prompted.

note

The descriptor does not set EnabledByDefault, so extraction alone does not enable the plugin. A project that skips this step compiles the module and then finds no CFCore Blueprint nodes and no CFCore page in Project Settings.

Step 4: add cfcore to Build.cs (C++ projects)

Blueprint-only projects can stop after step 3. C++ projects must declare the dependency, or every #include of a cfcore header fails to resolve and every symbol fails to link.

1. Open your game module's .Build.cs.
2. Add "cfcore" to PublicDependencyModuleNames, or to PrivateDependencyModuleNames if no other module needs to see cfcore types through your headers.
3. Run File > Refresh Visual Studio Project (or your IDE's equivalent) so the generated project files pick up the new include paths.

PublicDependencyModuleNames.AddRange(new string[] {
  "Core",
  "CoreUObject",
  "Engine",
  "InputCore",
  "cfcore"
});

Confirming the module is linked

Two entry points exist once the dependency is in place. Confirming both proves the install before you write integration code.

1. Include cfcore_context.h for the C++ singleton and cfcore_subsystem.h for the reflected engine subsystem.
2. Call CFCoreContext::GetInstance() for the ICFCore interface. The singleton is built on first call, so the pointer is usable before initialization, and IsInitialized() reports state.
3. Fetch UCFCoreSubsystem through GEngine. It derives from UEngineSubsystem, so the engine owns its lifetime and it is never spawned.

#include <Engine/Engine.h>
#include <cfcore_context.h>
#include <cfcore_subsystem.h>

using namespace cfcore;

void AMyGameMode::ConfirmCFCoreLinked() {
  ICFCore* core = CFCoreContext::GetInstance();
  UE_LOG(LogTemp, Display, TEXT("cfcore reachable, initialized: %d"),
         core->IsInitialized());

  UCFCoreSubsystem* subsystem = GEngine->GetEngineSubsystem<UCFCoreSubsystem>();
  if (subsystem == nullptr) {
    UE_LOG(LogTemp, Error, TEXT("UCFCoreSubsystem unavailable"));
  }
}

Blueprint: in any graph, search cfcoresu. The engine's subsystem accessor for CFCore Subsystem appears under Engine Subsystems, with one output pin returning the subsystem object. Every cfcore node (Initialize, Update Settings, Uninitialize and the rest) targets that object. If the accessor is absent, the plugin is not enabled or the module did not build.

What the descriptor declares

Field in cfcore.uplugin	Value
FileVersion	3
Version	1
VersionName	The release version of the package you downloaded
FriendlyName	cfcore
Category	Other
CreatedBy	Overwolf Ltd.
SupportURL	https://
CanContainContent	false
IsBetaVersion	false
Installed	false
Description, CreatedByURL, DocsURL, MarketplaceURL	empty strings

One module is declared, and nothing else:

Module	Type	Loading phase
cfcore	Runtime	Default

Runtime means the module compiles into packaged builds including Shipping. There is no Editor, UncookedOnly or DeveloperTool module. Default means the module loads after engine initialization, so cfcore is not available in PreDefault or earlier code. The Public/editor/ folder is part of the Runtime module, so UCFCoreBPLibrary and UCFCoreEditorSettings compile into shipping builds; only the settings-page registration in Private/cfcore_module.cpp is guarded by WITH_EDITOR.

The entry point is FCFCoreModule, registered with IMPLEMENT_MODULE(FCFCoreModule, cfcore). StartupModule calls RegisterSettings() only. ShutdownModule calls CFCoreContext::GetInstance()->Uninitialize(...) then UnregisterSettings(), so module teardown triggers SDK teardown whether or not your game called it.

Fields the descriptor does not contain

Absent field	Consequence
EngineVersion	The engine never version-gates the plugin. Unreal builds it on any version you open, and an incompatibility surfaces as a compile error rather than a refusal in the Plugins browser
PlatformAllowList / PlatformDenyList (and the older WhitelistPlatforms / BlacklistPlatforms)	No platform gating. The module is included in every target that enables the plugin. Platform exclusion has to come from your own target or module rules
SupportedTargetPlatforms	Packaging never filters the plugin out per platform
EnabledByDefault	The plugin stays off until a human ticks Enabled

SupportURL is the literal string https:// and is not a usable link. For support use cfforstudios@overwolf.com and the Developer Portal at console.curseforge.com.

warning

Use VersionName, not Version, to identify a release. Version is an integer that has stayed at 1 in both the cfcore and cfcore-sdk-ue-ui descriptors, so it does not distinguish releases. VersionName is the meaningful one, and the two plugins version independently. At startup Bootstrap::GetPluginVersion copies VersionName into FInternalSettings::pluginVersion verbatim and into FInternalSettings::userAgent, sent as the User-Agent header. That is the version CurseForge sees on a support ticket, so quote it when you raise one.

Build.cs dependencies

These are declared in Source/cfcore/cfcore.Build.cs. You do not repeat them in your own Build.cs, but this is the list to check when a platform target fails to link.

Dependency list	Modules
PublicDependencyModuleNames	Core, InputCore
PrivateDependencyModuleNames	CoreUObject, Engine, HTTP, Projects, Json, JsonUtilities, OpenSSL
Engine third party (private, static)	zlib, via AddEngineThirdPartyPrivateStaticDependencies
DynamicallyLoadedModuleNames	none
PublicIncludePaths / PrivateIncludePaths	none added

Build setting	Value	Effect
PCHUsage	ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs	IWYU-style includes are expected
PublicDefinitions	CFCORE_OBSOLETE_TESTS=0	Defined, but no shipped file reads it
bUseRTTI	true only on Win64 in DebugGame, Debug or Development	Test and Shipping, and every non-Win64 platform, compile without RTTI

Projects provides IPluginManager, which is how the plugin reads its own VersionName. Removing it breaks version reporting.

Removing the OpenSSL dependency

OpenSSL is referenced in two files only, Private/services/crypto_service/crypto_service_impl.h and .cpp. To opt out, remove "OpenSSL" from PrivateDependencyModuleNames and comment out #define CFCORE_WITH_OPENSSL 1 in that header.

danger

Both crypto entry points change behaviour, not one.

Function	Behaviour without OpenSSL
CryptoServiceImpl::DigestVerifyPS256	Logs "OpenSSL not defined - skipping verification" and returns true unconditionally. Every signature is treated as valid
CryptoServiceImpl::DecryptRsa	Logs "OpenSSL not defined - cannot decrypt RSA ciphertext" and returns false. Premium mod file details cannot be decrypted, so the premium install path fails

Analytics is unaffected: it uses only ExtractJwtPayload, which does not depend on OpenSSL. Do not remove OpenSSL in a build that ships premium mods.

note

licenses/ holds one notice, for the zip platform file work. The source tree also bundles minizip, bsdiff and HDiffPatch, whose notices live only inside headers under Private/services/compression/internal/minizip/ and Private/services/binary_diff_service/internal/. Include all of them in your attribution screen.

Engine version compatibility

The descriptor declares no EngineVersion, so compatibility is expressed in source preprocessor branches instead. Those branches carry live UE4 paths (ENGINE_MAJOR_VERSION == 4, minor >= 26) and have been adapted for engine changes up to and including UE 5.6, switching the ticker type, the HTTP retry Update() call, SetTimeout, OnRequestProgress64, the varargs macro, and the ReadAt file-handle override per version. The compatibility list on Unreal overview is the statement of record; the package itself contains no support matrix.

warning

There is a gap at UE 5.0 and 5.1. In Private/common/ue_compatibility_ticker.h the BackgroundableTicker.h include is compiled in only when the major version is below 5, while the branch that names FBackgroundableTicker is selected whenever the version is not 5.2 or later. On 5.0 and 5.1 the type is named without its include present. Confirm the versions certified for your title with cfforstudios@overwolf.com before planning an engine upgrade.

Platform coverage

There is no platform list in the descriptor. Platform support lives in code, in two places that do not carry identical entries. Game info and platforms reconciles both against the published list.

Bootstrap::GetPlatformName produces the runtime platform string sent to the backend, compiled per target.

Platform macro	Reported string
PLATFORM_WINGDK	windows_gdk
PLATFORM_XBOXONE	xbox_one
PLATFORM_XSX	xbox_xsx, or xbox_xss when FPlatformMisc::GetConsoleType() is EXSXConsoleType::Lockhart
PLATFORM_MAC	mac
PLATFORM_PS4	ps4
PLATFORM_PS5	ps5
PLATFORM_IOS	ios
PLATFORM_TVOS	tvos
PLATFORM_ANDROID	android
PLATFORM_SWITCH	switch
PLATFORM_HOLOLENS	hololens
PLATFORM_LINUX	linux
PLATFORM_WINDOWS	windows

warning

GetPlatformName has no fallback return for a target where none of those macros evaluate to 1. On such a platform the function has no defined return value. If you are bringing up a platform outside this table, that function is the first place to patch.

The API-facing enum is separate. ECFCorePlatform is UENUM(BlueprintType) over uint8, in Public/api/models/enums/platform.h.

Value	Numeric	Value	Numeric
None	0	IOS	8
Windows	1	TVOS	9
XboxOne	2	Android	10
XboxXS	3	Switch	11
Linux	4	WindowsServer	12
PS4	5	LinuxServer	13
PS5	6
Mac	7

The enum has dedicated server values and a single combined XboxXS, and it has no GDK and no HoloLens member. The Unreal overview page lists "Windows (GDK)" as supported and the runtime string table emits windows_gdk, but there is no ECFCorePlatform::WindowsGDK. Confirm with cfforstudios@overwolf.com which value to send for a GDK target.

Server variants come from settings, not from the build target: isServer adds a _server suffix to the platform header, and its companion is isServerPcOnly, not PcOnly. See Initialization and settings.

Installing the mod browser plugin

Only cfcore is in this release package. cfcore-sdk-ue-ui, the UMG in-game mod browser documented on Mod browser, ships as its own separately versioned package and extracts to Plugins/cfcore_ui. Install cfcore first: cfcore_ui.uplugin declares cfcore as an enabled plugin dependency and its module privately depends on the cfcore module, so enabling it against a project without cfcore present fails at descriptor resolution before compilation. Unlike cfcore it sets CanContainContent to true, ships a Content folder, and adds UMG, Slate, SlateCore, DeveloperSettings, RHI, RenderCore and XmlParser to its dependency lists. The cf-ue-editor-plugin editor integration is a third, separate package.

Post-install checklist

Check	Failure signature if it is wrong
Plugins/cfcore/cfcore.uplugin exists at exactly that depth	The plugin never appears in Edit > Plugins
The plugin folder is still named cfcore	Null dereference when the plugin reads its own descriptor
The module built without errors	Recurring Missing Modules prompt on every project open
Enabled is ticked in Edit > Plugins	No CFCore nodes in Blueprint, no CFCore page in Project Settings
C++ projects: "cfcore" is in your Build.cs and IDE project files were refreshed	cfcore_context.h not found, or unresolved externals at link
The CFCore Subsystem accessor appears in the Blueprint action list	Plugin not enabled, or the module did not build
The version in the Plugins browser matches the release you intended to ship	Support tickets carry the wrong VersionName, since it feeds the User-Agent header
Third-party notices from licenses/ and the bundled minizip, bsdiff and HPatch sources are in your attribution screen	Missing attribution at certification or legal review

Next steps

The plugin is installed but the SDK is not running. Go to Initialization and settings to set your game ID and API key, build an FCFCoreSettings, and call Initialize.

For engine version certification, platform bring-up beyond the tables above, and enabling premium mods, subscriptions or an authentication provider for your game, contact cfforstudios@overwolf.com. Game records, API keys and authentication settings are managed in the Developer Portal at console.curseforge.com.