CodeForge

1 Overview

CodeForge is an editor plugin that lets you define Unreal Engine C++ classes, structs, enums, and interfaces visually — then generates complete, compile-ready header and source files. Instead of hand-writing UPROPERTY/UFUNCTION macros, specifier strings, and replication boilerplate, you configure them through a node graph and a details panel, and CodeForge emits correct C++ instantly.

2 Installation

From Fab

1. Purchase and download CodeForge from fab.com.
2. Extract the zip. You will find HostProject/Plugins/CodeForge/.
3. Copy the CodeForge folder into your project's Plugins/ directory.
4. Regenerate project files (right-click your .uproject → Generate Visual Studio project files).
5. Open the editor. CodeForge loads automatically — check Edit → Plugins to verify.

From Source

Clone the repository into YourProject/Plugins/CodeForge. The plugin has two modules:

3 Quick Start

1. Create a CodeForge Blueprint: In the Content Browser, right-click → CodeForge → CodeForge Blueprint. Name it (e.g., CFB_PlayerCharacter).
2. Open the editor: Double-click the asset. The CodeForge Asset Editor opens with a node graph on the left and a code preview panel on the right.
3. Set Blueprint Kind: In the Details panel, choose Class, Struct, Enum, or Interface.
4. Configure identity: Set ClassName (e.g., MyCharacter), ClassType (e.g., Character), and ModuleTarget.
5. Add members: Right-click the graph → add Property, Function, RPC, or Delegate nodes. Configure each in the Details panel.
6. Review the preview: The code preview panel shows the generated .h and .cpp in real time.
7. Generate: Click the Generate Code toolbar button. Files are written to your module's Source directory.

4 Architecture

CodeForge is organized into distinct layers, each with a single responsibility:

5 CodeForge Blueprints

A CodeForge Blueprint (UCodeForgeBlueprint) is the root data asset that stores your entire type definition. It lives in the Runtime module and is a pure data object — no UI logic, no code generation. This means it can be loaded and inspected in any context.

Core Properties

Class Prefix System

CodeForge automatically prepends the correct UE prefix based on the type:

6 The Node Graph

Each CodeForge Blueprint has a visual node graph (UCodeForgeEdGraph) managed by UCodeForgeEdGraphSchema. The central type node (Class, Struct, Enum, or Interface) represents the type itself, and member nodes connect to it representing properties, functions, RPCs, and delegates.

Node Types

Graph Interactions

• Right-click context menu: Add any member node type appropriate for the current BlueprintKind.
• Drag connections: Connect member nodes to the central type node.
• Undo/Redo: All graph operations are wrapped in FScopedTransaction for full undo support.
• Validation overlays: Nodes display real-time error/warning badges from the validation system.

7 Code Generation

Code generation is handled by FCodeForgeGenerator. The process has three phases:

Phase 1 — BuildContext()

Reads the UCodeForgeBlueprint and populates a FCodeForgeTemplateContext with:

• Variables: ClassName, ClassPrefix, ParentClassName, ParentInclude, ModuleAPI, ClassSpecifiers, ConstructorBody, etc.
• Conditions: Replicated, HasRepNotifyProperties, HasNativeEventFunctions
• Arrays: Properties, Functions, RPCs, Delegates, ReplicatedProperties, RepNotifyProperties, NativeEventFunctions, ImplementedFunctions, ServerRPCValidations, AdditionalIncludes, InterfaceIncludes

Phase 2 — Template Selection

Based on BlueprintKind and ClassType, the generator selects the appropriate .cft template pair:

Phase 3 — Template Processing

The FCodeForgeTemplateEngine processes the template text with the context and returns the final C++ output. See the Template Engine section for syntax details.

8 Classes

The most feature-rich blueprint kind. Supports all member types: properties, functions, RPCs, delegates, replication, and interface implementation.

Supported Class Types

Properties

Each FCodeForgePropertyDef generates a UPROPERTY() declaration. Available specifiers:

UPROPERTY(EditAnywhere, BlueprintReadWrite, ReplicatedUsing=OnRep_Health)
float Health = 100.0f;

Functions

Each FCodeForgeFunctionDef generates a UFUNCTION() declaration:

UFUNCTION(BlueprintPure)
float GetHealthPercent() const;

RPCs (Remote Procedure Calls)

Each FCodeForgeRPCDef generates a server, client, or multicast RPC:

// Header
UFUNCTION(Server, Reliable, WithValidation)
void ServerRequestAttack();

// Source — _Implementation
void AMyCharacter::ServerRequestAttack_Implementation()
{
    // TODO
}

// Source — _Validate
bool AMyCharacter::ServerRequestAttack_Validate()
{
    return true;
}

Delegates

Each FCodeForgeDelegateDef generates a DECLARE_*_DELEGATE macro and a UPROPERTY(BlueprintAssignable) member:

The parameter count suffix is computed automatically: _OneParam, _TwoParams, ..., up to _NineParams (UE5 maximum).

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnHealthChanged, float, NewHealth, float, MaxHealth);

UPROPERTY(BlueprintAssignable, Category = "Events")
FOnHealthChanged OnHealthChanged;

Replication

When bReplicated is true on the blueprint, CodeForge generates the full replication setup:

Replication Conditions

Each replicated property can specify a condition via ECodeForgeRepCondition:

(Plus ReplayOrOwner, ReplayOnly, SimulatedOnlyNoReplay, SimulatedOrPhysicsNoReplay, SkipReplay, Dynamic)

9 Structs

Struct blueprints generate a USTRUCT(BlueprintType) with a GENERATED_BODY() macro and property members. Structs use the F prefix.

USTRUCT(BlueprintType)
struct MYMODULE_API FItemData
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    FString ItemName;

    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 StackCount = 1;
};

10 Enums

Enum blueprints generate a UENUM(BlueprintType) with uint8 backing type and typed entries.

UENUM(BlueprintType)
enum class EItemRarity : uint8
{
    Common,
    Uncommon,
    Rare,
    Epic,
    Legendary
};

11 Interfaces

Interface blueprints generate the standard UE5 dual-class interface pattern: a UINTERFACE stub class and an I-prefixed abstract class with BlueprintNativeEvent function declarations.

UINTERFACE(MinimalAPI, Blueprintable)
class UDamageable : public UInterface
{
    GENERATED_BODY()
};

class MYMODULE_API IDamageable
{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintNativeEvent)
    void ReceiveDamage(float Amount);

    UFUNCTION(BlueprintNativeEvent)
    float GetCurrentHealth() const;
};

12 Asset Editor

Double-clicking a CodeForge Blueprint opens the CodeForge Asset Editor (FCodeForgeAssetEditor), a custom standalone editor with:

• Node Graph Panel (left): The visual node graph for designing your type.
• Code Preview Panel (right): Real-time display of the generated .h and .cpp code.
• Details Panel (bottom-right): Standard UE5 property editor for the selected node or blueprint.
• Toolbar: Buttons for Generate Code, Validate, and toggling the code preview.

Code Preview

The code preview panel updates in real time as you modify properties in the Details panel. It shows two tabs:

• Header (.h) — the generated header with all includes, macros, class declaration, and member declarations.
• Source (.cpp) — the generated source with constructor, replication, function implementations, RPC stubs, etc.

13 Node Visuals

CodeForge uses a custom SGraphNode_CodeForge widget with enhanced visual features:

• Color-coded title bars — each node type has a distinct color (configurable in Settings).
• Validation badges — error and warning indicators appear directly on nodes in real time.
• Body tinting — type nodes (Class/Struct/Enum/Interface) get a subtle color tint.
• Configurable font sizes — separate sizes for type nodes (default: 12) and member nodes (default: 10).

14 Plugin Settings

Access via Edit → Project Settings → Plugins → CodeForge (UCodeForgeSettings).

Code Generation

Editor

Appearance — Node Colors

Appearance — Branding

15 Template Engine

The FCodeForgeTemplateEngine is a dependency-free Handlebars-inspired string template processor. It supports four directives:

Context Structure

struct FCodeForgeTemplateContext
{
    TMap<FString, FString>  Variables;    // {{Key}} → Value
    TMap<FString, bool>     Conditions;   // {{#if Key}}
    TMap<FString, TArray<FCodeForgeTemplateArrayItem>> Arrays; // {{#each Key}}
};

Template Example

{{> copyright_header}}

#pragma once

#include "CoreMinimal.h"
#include "{{ParentInclude}}"
{{#each AdditionalIncludes}}
#include "{{IncludePath}}"
{{/each}}
#include "{{ClassName}}.generated.h"

UCLASS({{ClassSpecifiers}})
class {{ModuleAPI}} {{ClassPrefix}}{{ClassName}} : public {{ParentClassName}}
{
    GENERATED_BODY()

{{#each Properties}}
    UPROPERTY({{PropertySpecifiers}})
    {{PropertyType}} {{PropertyName}}{{PropertyDefault}};

{{/each}}
};

Include Resolver

The template engine uses SetTemplateResolver() to resolve {{> name}} includes. CodeForge resolves templates from the Content/Templates/ directory hierarchy. The resolver supports a maximum recursion depth of 10 to prevent infinite loops.

16 Template Reference

All templates live in Plugins/CodeForge/Content/Templates/:

17 Validation Rules

CodeForge validates blueprints in real time through UCodeForgeBlueprint::Validate(). Each rule produces either an Error (blocks generation) or a Warning (advisory, with optional auto-fix).

Additional checks include: type validation (empty types, miscapitalized types like Float → float, invalid C++ type names), parameter validation (empty parameter names, bad types), delegate parameter count limit (max 9), and enum entry validation (duplicate entries, empty names, minimum 1 entry).

18 Module Scanner

FCodeForgeModuleScanner automatically discovers all C++ modules in your project by scanning for .Build.cs files. For each module it determines:

• ModuleName — parsed from the .Build.cs filename
• APIMacro — derived as MODULENAME_API (uppercase module name + _API)
• SourceDir, PublicDir, PrivateDir — standard UE module directory layout

This powers the ModuleTarget dropdown in the blueprint editor, letting you pick any module in your project as the output target without manual configuration.

19 Auto-Fix System

Several validation rules offer automatic fixes via ApplyAutoFix(AutoFixId). When a validation result has a non-empty AutoFixId, the editor can apply the fix with one click.

20 Enums Reference

ECodeForgeBlueprintKind

ECodeForgeClassType

ECodeForgeRPCMode

ECodeForgeDelegateType

ECodeForgeRepCondition

ECodeForgeValidationSeverity

21 Specifier Builder Reference

Each definition type has a BuildSpecifierString() method that generates the correct UE5 macro arguments. Here's how specifiers combine:

Property Specifier Priority

Edit specifiers are mutually exclusive (first true wins):

VisibleAnywhere > EditAnywhere > EditDefaultsOnly > EditInstanceOnly

Blueprint specifiers are mutually exclusive:

BlueprintReadWrite > BlueprintReadOnly

Replication: RepNotify takes priority over plain Replicated — generates ReplicatedUsing=OnRep_Name.

Function Specifier Priority

Exec > BlueprintPure > BlueprintCallable

BlueprintNativeEvent is additive (can combine with the above). Category is appended when non-empty.

Type Correction Map

The validator recognizes common miscapitalizations and suggests corrections:

22 Troubleshooting