/ue-blueprint-cpp-interop

Blueprint-Facing Specifiers and meta= Keys

Every key below is declared in Engine/Source/Runtime/CoreUObject/Public/UObject/ObjectMacros.h in UE 5.8, in the UC (UCLASS), UI (UINTERFACE), UF (UFUNCTION/UDELEGATE), UP (UPROPERTY), US (USTRUCT) or UM (metadata) enumerations; the line number after each name is its declaration. Parsing is case-insensitive, so engine headers write both Config=Game and config=Game. A key that is not in one of those enumerations is not a specifier — UHT ignores it silently or errors.

meta= values are strings: meta=(ClampMin="0.0"), meta=(BlueprintInternalUseOnly="true"). Boolean-style keys may be written bare (meta=(Latent), meta=(EditConditionHides)).

UFUNCTION Specifiers

RPC specifiers (Server, Client, NetMulticast, Reliable, Unreliable, WithValidation) live in the same enumeration but belong to ue-networking-replication.

UFUNCTION meta= Keys

BlueprintThreadSafe (1313) is class metadata for a UBlueprintFunctionLibrary: it marks every function in the library callable off the game thread in an Animation Blueprint. Use NotBlueprintThreadSafe on individual exceptions.

UPROPERTY Specifiers That Matter to Blueprint

UHT errors, not warnings:

UPROPERTY meta= Keys

Categories for gameplay-tag filtering is declared in the same header inside namespace GameplayTagsManager (line 2470), not in UM.

UPARAM

UPARAM(...) (ObjectMacros.h:783) annotates one parameter:

Without UPARAM(ref), a bare T& parameter is given OutParm only and becomes an output pin. A const T& parameter stays an input.

UCLASS Specifiers That Matter to Blueprint

Useful class meta= keys: DisplayName (1282), BlueprintSpawnableComponent (1261, puts a component in the Add Component menu), ExposedAsyncProxy (1310, the async node returns the proxy object), IsBlueprintBase (1288), DontUseGenericSpawnObject (1307), BlueprintThreadSafe (1313), RestrictedToClasses (1300, limits which graphs a function library appears in).

UINTERFACE Specifiers

The UI:: enum documents these four (ObjectMacros.h:965-984). UHT also accepts UCLASS specifiers such as BlueprintType on a UINTERFACE; the engine uses UINTERFACE(BlueprintType, MinimalAPI) (ActorSoundParameterInterface.h:28):

Interface meta= keys: CannotImplementInterfaceInBlueprint (1834) and CannotGenerateMessageNodes (1847, suppresses the type-agnostic Message nodes). Engine interfaces also carry BlueprintType so the interface is usable as a variable type — UActorSoundParameterInterface is declared UINTERFACE(BlueprintType, MinimalAPI).

USTRUCT and UENUM

UENUM(BlueprintType) requires enum class E… : uint8; any other underlying type is a UHT error ("Invalid BlueprintType enum base - currently only uint8 supported"). Per-enumerator UMETA(...) (ObjectMacros.h:782) takes DisplayName="…" and Hidden — ESpawnActorScaleMethod::SelectDefaultAtRuntime in GameFramework/Actor.h:93 is an engine example of UMETA(Hidden).

Containers: TArray, TSet and TMap are Blueprint-exposable only when their element type — and, for TMap, their key type — is itself Blueprint-supported, and they cannot nest, because each clears its own CanBeContainerValue/CanBeContainerKey capability in UnrealHeaderTool.

A Worked Property Example

// MyStatsComponent.h
#pragma once
#include "CoreMinimal.h"
#include "Components/ActorComponent.h"
#include "StructUtils/InstancedStruct.h"
#include "Templates/SubclassOf.h"
#include "MyStatsComponent.generated.h"

class AActor;
class UStaticMesh;

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FMyHealthChangedSignature, double, NewHealth);

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class MYGAME_API UMyStatsComponent : public UActorComponent
{
    GENERATED_BODY()
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Stats", meta=(ClampMin="0.0", UIMax="500.0"))
    double MaxHealth = 100.0;                       // Real pin, slider capped at 500

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Stats", meta=(ExposeOnSpawn="true"))
    FName StatsRowName;                             // extra pin on Spawn Actor from Class

    UPROPERTY(EditAnywhere, Category="Stats", meta=(InlineEditConditionToggle))
    bool bOverrideRegen = false;                    // renders as the checkbox on the row below

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Stats", meta=(EditCondition="bOverrideRegen", EditConditionHides))
    double RegenPerSecond = 1.0;                    // row disappears unless bOverrideRegen is set

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Stats")
    TObjectPtr<UStaticMesh> Mesh;                   // object pin

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Stats", meta=(MustImplement="/Script/MyGame.MyInteractable"))
    TSubclassOf<AActor> SpawnClass;                 // class pin, picker filtered by the interface

    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Stats")
    TSoftObjectPtr<UStaticMesh> LazyMesh;           // soft object pin

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Stats")
    FInstancedStruct Effect;                        // struct pin, concrete type chosen in the editor

    UPROPERTY(BlueprintAssignable, BlueprintCallable, Category="Stats")
    FMyHealthChangedSignature OnHealthChanged;      // Bind Event and Broadcast nodes

    UPROPERTY(BlueprintGetter=GetShield, BlueprintSetter=SetShield, Category="Stats")
    double Shield = 0.0;

    UFUNCTION(BlueprintGetter)
    double GetShield() const { return Shield; }

    UFUNCTION(BlueprintSetter)
    void SetShield(double NewShield);

    UFUNCTION(BlueprintCallable, Category="Stats")
    void ApplyDamage(double Amount);

private:
    UPROPERTY(EditAnywhere, Category="Stats", meta=(AllowPrivateAccess="true"))
    double CurrentHealth = 100.0;
};

// MyStatsComponent.cpp
#include "MyStatsComponent.h"

void UMyStatsComponent::SetShield(double NewShield)
{
    Shield = FMath::Clamp(NewShield, 0.0, MaxHealth);
}

void UMyStatsComponent::ApplyDamage(double Amount)
{
    CurrentHealth = FMath::Max(0.0, CurrentHealth - Amount);
    OnHealthChanged.Broadcast(CurrentHealth);
}

A BlueprintSetter is the only way to run validation on a Blueprint write; a plain BlueprintReadWrite property is written directly by the VM with no hook.