CodeForge

Visual C++ Class Designer & Code Generator for Unreal Engine 5

Describe a gameplay type in a node graph or a JSON file. CodeForge checks it against the rules UnrealHeaderTool and the compiler enforce, then writes the header and source into your module, with replication, RPCs, delegates and interface overrides already wired.

v0.5.0 · UE 5.5–5.8

1 Overview

CodeForge is an editor plugin. A definition (a CodeForge Blueprint asset, or an entry in a .codeforge.json file) describes one C++ type: its parent, members, specifiers, network behaviour and function bodies. CodeForge turns it into a compile-ready .h/.cpp pair in the module you choose and keeps it in sync as the definition changes.

2 What's New in 0.5.0

0.3.0 added:

3 Installation

1. Copy the plugin into Plugins/ of a C++ project. A Blueprint-only project needs one C++ class first (Tools → New C++ Class).
2. Regenerate project files and build, or open the project and let the editor build the plugin.
3. Check Edit → Plugins → Editor → CodeForge.

4 Quick Start

1. Create: Content Browser → Add → CodeForge → CodeForge Blueprint. Pick Replicated Actor, your module, an optional sub-folder, and keep Starter content on.
2. Name it without a prefix: Beacon becomes ABeacon.
3. Design: right-click the graph to add properties, functions, RPCs and delegates. The preview on the right updates as you edit.
4. Generate: click Generate. New files refresh the IDE project. Build or use Live Coding.

To see a complete game first, open the Arena sample (§ Arena) or use Tools → CodeForge → Import Sample Pack in your own project.

5 Architecture

6 Definitions

A definition is the single source of truth for a type. In the editor it is a CodeForge Blueprint asset; on disk it can also be a .codeforge.json entry (§ JSON). Both carry the same fields.

Naming and prefixes

Enter the name without its Unreal prefix. CodeForge adds the right one, and keeps a prefix you already typed instead of doubling it.

Where files go

Source/<Module>/Public/<SubDirectory>/<Name>.h and Source/<Module>/Private/<SubDirectory>/<Name>.cpp. Enums are header-only. Any game or plugin module of the project can be the target.

7 The Node Graph

Each asset has one type node (Class, Struct, Enum or Interface). Member nodes wire into it. Only members connected to the type node are generated, so a disconnected node is a quick way to park an idea.

Right-click empty space for the add menu; the type nodes are offered only while the graph has none. Node badges show validation results; right-click a node for its Fix: entries (§ Auto-Fix).

8 Code Generation

• Generate validates first and refuses to write on errors.
• Files without the // Generated by CodeForge - DO NOT EDIT marker are never replaced without confirmation.
• Batches (folder, multi-selection, commandlet) generate enums → structs → interfaces → classes, and resolve interfaces from the batch first, then from assets.
• Creating new files triggers an IDE project refresh (setting). Changing only function bodies can go through Live Coding automatically; layout or reflection changes prompt, because they need a rebuild.
• Output is normalised: LF line endings, four-space indentation, no trailing whitespace, a single final newline. The same definition always produces the same bytes.

9 Classes

Parents

Class options

Also per class: description (doc comment), constructor body, extra source includes, implemented interfaces and their function bodies.

Properties

Edit flags (VisibleAnywhere, EditAnywhere, EditDefaultsOnly, EditInstanceOnly), Blueprint access, Replicated / RepNotify with condition and OnRep_ body, ExposeOnSpawn, SaveGame, Transient, Config, AdvancedDisplay, free meta tags, an include path for the type, a default value, a description, and access level. Category is written only when the property is visible to the editor or Blueprints, which avoids a UHT warning.

/** Current health, replicated to clients. */
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, ReplicatedUsing=OnRep_Health, Category="Arena")
float Health = 100.f;

Functions

BlueprintCallable, BlueprintPure (requires an output), const, BlueprintNativeEvent (declares and defines _Implementation), BlueprintImplementableEvent (no body), static, CallInEditor, Exec console commands, plain C++ helpers (bUFunction off), virtual and override, parameter defaults, meta tags and access levels. Overrides of engine functions (BeginPlay, Tick, Initialize) are plain virtual ... override, never UFUNCTION.

RPCs & replication

Server, Client and NetMulticast RPCs, reliable or unreliable. Server RPCs get WithValidation and a _Validate stub. Replicated properties produce GetLifetimeReplicatedProps with DOREPLIFETIME_CONDITION.

void UArenaHealthComponent::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const
{
    Super::GetLifetimeReplicatedProps(OutLifetimeProps);

    DOREPLIFETIME_CONDITION(UArenaHealthComponent, Health, COND_None);
}

void UArenaHealthComponent::ServerRequestHeal_Implementation(float Amount)
{
    Heal(Amount);
}

Delegates

Dynamic multicast (Blueprint events, BlueprintAssignable), dynamic, multicast and single, with 0–9 parameters. Each delegate generates its signature (F<Name>Signature) above the class and a member.

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnHealthChangedSignature, float, NewHealth, float, Delta);
...
UPROPERTY(BlueprintAssignable, Category="Arena")
FOnHealthChangedSignature OnHealthChanged;

10 Interfaces

An Interface definition generates the UINTERFACE and its I class. Blueprintable interfaces take BlueprintNativeEvent/BlueprintImplementableEvent functions; non-Blueprintable ones take virtual C++ functions. Validation enforces UHT's rules for both.

A class that lists the interface under Interfaces inherits it and gets the overrides automatically: _Implementation for events, virtual ... override otherwise. Bodies come from Interface Function Bodies; callers use IArenaDamageable::Execute_ApplyArenaDamage(Target, ...).

11 Structs

USTRUCT(BlueprintType) with properties, an optional parent struct and its include (FTableRowBase + Engine/DataTable.h for Data Table rows). Blueprint-visible struct members must be public, and replication flags aren't allowed on struct members. Both are validated.

12 Enums

enum class E... : uint8 with display names, hidden entries, doc comments and explicit values (validated to fit uint8). Bitflags enums write power-of-two values, meta=(Bitflags, UseEnumValuesAsMaskValuesInEditor="true") and ENUM_CLASS_FLAGS, ready for a Bitmask property.

13 New Type Wizard

Opens when you create a CodeForge Blueprint. Choose one of 23 archetypes:

Then pick the target module (every module in the project is listed) and sub-folder, and decide whether to add starter content: typical members for that archetype, such as a replicated Health with OnRep and a server RPC, or an Exec cheat on a player controller. Every archetype is compiled in the test suite with and without starter content.

14 Asset Editor

The Details panel edits the selected node, or the type itself when nothing is selected. Fields that the graph owns are hidden there, so the two can't disagree. Undo and redo cover graph and Details edits and refresh validation and preview.

Code Preview

Shows the exact header and source that Generate will write, syntax-coloured, plus a status chip comparing it with the disk:

Menus

• Content Browser, right-click CodeForge assets (multi-select works): Generate C++, Validate (results in the CodeForge Message Log), Export Schema..., Open Generated C++.
• Tools → CodeForge: Import Schema..., Generate All CodeForge Assets, Import Sample Pack, CodeForge Documentation.

15 Plugin Settings

Project Settings → Plugins → CodeForge:

16 Lift to C++

Lift to C++ turns an existing Blueprint into a C++ base class. It generates a C++ parent that holds the Blueprint's variables, functions, event dispatchers and custom events, plus C++ versions of the Blueprint structs and enums they use. After a build it reparents the Blueprint onto that class and redirects every reference. Each step is verified, and the whole change can be undone.

1. Right-click a Blueprint → Lift to C++..., or use the Lift to C++ button in the Blueprint editor toolbar.
2. The dialog lists every member with its C++ declaration, and explains anything that stays. Name the class (default: the Blueprint's name without BP_, plus Base), choose the module and folder, and untick members you want to keep in the Blueprint.
3. CodeForge saves the definitions to <Blueprint folder>/CodeForge, generates the C++, adds missing module dependencies to Build.cs and refreshes the IDE project.
4. Build and restart. At startup CodeForge offers Complete Now; the context menu and the toolbar (Complete Lift) work too.

What moves, what stays

The following stay in the Blueprint, each with its reason:

• names that aren't C++ identifiers;
• variables typed with a Blueprint class or a bitmask Blueprint enum;
• RepNotify, Config, Field Notify and Expose-to-Cinematics variables;
• replicated, Call In Editor and overriding custom events;
• RepNotify functions, Call In Editor and thread-safe functions, pure functions without an output, pass-by-reference inputs, and input defaults C++ can't hold (texts, vectors);
• anything whose C++ wouldn't compile, such as a parameter named like a variable.

Graph logic stays in the Blueprint: function graphs become overrides of their C++ declarations.

Complete, verification and undo

Complete Lift to C++ checks that the compiled class and structs match the Blueprint, backs up the affected assets, then, as one undo transaction:

• redirects the Blueprint structs and enums everywhere: variables, parameters, Make/Break, Switch and Select nodes, split pins and defaults;
• reparents the Blueprint and removes its own copies of the lifted members;
• turns the lifted custom events and functions into overrides;
• points other Blueprints' references at the C++ members;
• compiles everything affected.

It then verifies:

• the parent is the new class;
• nothing lifted is left in the Blueprint;
• everything compiles;
• no pin link was lost;
• every lifted function overrides its C++ declaration;
• no replaced struct or enum is still in use;
• class defaults and per-instance values in maps are unchanged.

Scripting: analyze_lift, lift_to_cpp, complete_lift, restore_lift_backup (Python) and -Lift= / -CompleteLift= (commandlet). The sample project's /Game/CodeForgeSamples/Lift/BP_Beacon is ready to try. Full guide: docs/lift-to-cpp.md.

17 JSON Definitions

*.codeforge.json files hold any number of definitions with the same fields as the assets. Keys are the C++ field names, and defaults are omitted on export. Use them for source control, code review, CI and sharing. Schema/codeforge.schema.json gives editors completion and validation; an automation test keeps it in step with the data model.

{
  "SchemaVersion": 1,
  "Definitions": [
    { "ClassName": "HealthComponent", "ClassType": "ActorComponent",
      "ModuleTarget": "MyGame", "bReplicated": true,
      "Properties": [ { "Name": "Health", "Type": "float", "DefaultValue": "100.f",
                        "bReplicated": true, "bRepNotify": true } ] }
  ]
}

Import: Tools → CodeForge → Import Schema.... Export: right-click assets → Export Schema.... Invalid enum values fail the import and name the field; unknown keys are logged and ignored. The full field reference is in docs/json-schema.md.

Definition files next to the code. Generating a type also writes its definition as <Name>.codeforge.json beside the header (Turret.h, Turret.codeforge.json). The definition travels in the same commit and pull request as its code, as one small file per type with deterministic output, so it diffs line by line and merges as text. Assets are binary and can't be merged: resolve a conflict in the JSON, then run -run=CodeForge -Schema=Source/MyGame -Generate (code) or -Import=Source/MyGame (assets). Both read every *.codeforge.json under a folder. A JSON file CodeForge didn't write is never overwritten without asking. Turn the files off with the Write Definition Files setting.

18 Commandlet & CI

UnrealEditor-Cmd.exe MyGame.uproject -run=CodeForge -Schema=Design/Game.codeforge.json -Generate -unattended -nullrhi

Exit code 0 on success, 1 on any error. Because the output is deterministic, git diff --exit-code -- Source after generation is a reliable "generated code is up to date" check.

19 Python

import unreal
lib = unreal.CodeForgeEditorLibrary

result = lib.generate_folder("/Game/Design", False)
if not result.success:
    unreal.log_error(result.message)

result, header, source = lib.preview_code(unreal.load_asset("/Game/Design/Turret"))
assets, error = lib.import_schema("D:/Design/Game.codeforge.json", "/Game/Design", True)
lib.apply_auto_fixes(assets[0])

Also: generate_code, generate_code_in_project, validate_definition, export_schema, find_definitions. Operations return CodeForgeScriptResult (success, message, files), so a failure always carries its reason. The same functions are available to Editor Utility Blueprints under CodeForge | Editor.

20 Validation Rules

21 Auto-Fix

Some findings carry a fix. In the graph, right-click the flagged node and choose Fix: <message>, or click Fix All. Fixes are transactions, so Undo reverts them.

Fix All repeats until nothing fixable is left, because one fix can uncover another (replicating a property reveals that the class must replicate). Python: apply_auto_fixes(asset).

22 Templates

Output comes from .cft templates in Plugins/CodeForge/Content/Templates. Set Custom Template Path to a project folder and copy only the files you want to change. Lookup is per file, and anything you don't override falls back to the built-ins.

Tags alone on a line vanish with their line, and the output is normalised afterwards. Keep // Generated by CodeForge - DO NOT EDIT in copyright_header.cft: it is how CodeForge recognises its own files. The values available to each template are listed in docs/templates.md.

23 Module Layout

Generation targets are the game modules declared in the .uproject (Source/<Module>) and the modules of project plugins, including nested ones such as Plugins/GameFeatures/<Plugin>. A module counts when its <Module>.Build.cs exists; CodeForge's own modules are never targets. It always writes headers to Public/ and sources to Private/, including for modules that keep their files flat, because UnrealBuildTool only adds Public/ to the include path. The .cpp includes its header by its path under Public/ ("Arena/ArenaTurret.h").

24 Arena Sample

A small target-range game in which all 16 gameplay types are CodeForge output: game mode, player controller, HUD, turrets, colour-coded targets, pickups, a replicated health component, a damage interface, a score subsystem with save game, a Data Table row, a bitflags enum and a function library. Definitions: Samples/Arena/Arena.codeforge.json.

• In the CodeForge project: open the default map and press Play. Fire with the left mouse button or Space. Console: ArenaSpawn 5, ArenaKillAll, ArenaAddScore 100.
• In your project: Tools → CodeForge → Import Sample Pack (retargets to your module), then Generate C++ and build.
• The automation test CodeForge.Sample.ArenaPlays plays the map and checks that targets spawn and kills are scored.

25 Verification

CodeForge's own suite (Automation RunTests CodeForge) covers the data model, validation, templates, generator output, JSON round-trips, commandlet, Python library, graph sync and auto-fix, the wizard archetypes, UI smoke tests and a PIE run of the sample. Scripts/Verify-GeneratedCode.ps1 additionally emits every test definition, every archetype and the whole sample into a scratch project and compiles it with UnrealBuildTool.

26 Troubleshooting