← all publishers

kevinpbuckley

@kevinpbuckley source repo

Report this profile Claim this profile

• 100 skills
• 0 followers
• 605 repo stars
• last month last updated

1. ▌
   Gas · kevinpbuckley

   Author and PIE-verify Gameplay Ability System content — abilities, attribute sets, gameplay effects, gameplay events, costs/cooldowns, cues — by composing Epic's GASToolsets/GameplayTagsToolset with Blueprint/Object tools and Python. Use when the user asks to add abilities, attributes, damage/buff effects, cooldowns, gameplay cues, or to inspect a live ASC.
   605 repo stars
2. ▌
   Bulk Maintenance · kevinpbuckley

   Plan, dry-run, apply, verify, roll back, and resume explicit bounded batches for Blueprint interface migration, metadata hygiene, asset naming/organization, and unused-asset cleanup preparation.
   605 repo stars
3. ▌
   Ue Subsystems · kevinpbuckley bundle

   Implement engine-managed singletons scoped to a defined lifetime using Unreal's Subsystem framework — UEngineSubsystem, UGameInstanceSubsystem, UWorldSubsystem, UTickableWorldSubsystem, and ULocalPlayerSubsystem. Covers Initialize/Deinitialize lifecycle, ShouldCreateSubsystem for conditional creation, InitializeDependency for ordered init, and Blueprint/Python exposure. Use when building a service or manager (save system, ability registry, match service, analytics) and deciding whether to scope it to the process, game session, world, or local player — and when choosing between a subsystem, a manager actor, or a GameInstance override.
   605 repo stars
4. ▌
   Ue Niagara Vfx · kevinpbuckley bundle

   Create and control visual effects using Unreal's Niagara system — UNiagaraSystem, UNiagaraComponent, UNiagaraFunctionLibrary; the system/emitter/module/parameter hierarchy; spawning effects at a world location or attached to an actor/socket (SpawnSystemAtLocation, SpawnSystemAttached); setting User Parameters from C++ (SetVariableFloat, SetVariableVec3, SetVariableActor, SetFloatParameter, SetColorParameter); CPU vs GPU simulation trade-offs; Data Interfaces (skeletal mesh, static mesh, collision); component lifetime management (bAutoDestroy, Activate/Deactivate, OnSystemFinished); and Niagara Data Channels. Use when spawning particle or VFX (fire, smoke, impacts, trails, magic), attaching effects to actors or sockets, driving an effect from gameplay parameters, choosing CPU vs GPU emitters, or migrating from Cascade (deprecated).
   605 repo stars
5. ▌
   Ue Gameplay Tags · kevinpbuckley bundle

   Use Gameplay Tags in Unreal C++ — hierarchical FName-based labels (FGameplayTag, FGameplayTagContainer), native tag declaration and definition (UE_DECLARE_GAMEPLAY_TAG_EXTERN / UE_DEFINE_GAMEPLAY_TAG / UE_DEFINE_GAMEPLAY_TAG_COMMENT / UE_DEFINE_GAMEPLAY_TAG_STATIC), tag registration via UGameplayTagsManager, runtime lookup with RequestGameplayTag, container operations (AddTag, RemoveTag, HasTag, HasTagExact, HasAny, HasAll), single-tag matching (MatchesTag, MatchesTagExact, MatchesAny), data-driven conditions with FGameplayTagQuery, the IGameplayTagAssetInterface, and config via DefaultGameplayTags.ini / DataTable sources. Use when modeling states, categories, damage types, ability identifiers, or any open-ended hierarchical label that multiple systems share; when replacing brittle enums or string comparisons; or when working with GAS, AI behavior trees, animation, or UI systems that gate behavior on tags.
   605 repo stars
6. ▌
   Ue Memory And Gc · kevinpbuckley bundle

   Manage UObject lifetime and plain C++ memory in Unreal Engine. Covers the garbage collector reachability cycle and root set, keeping UObjects alive with UPROPERTY and TObjectPtr, non-owning TWeakObjectPtr, path-only TSoftObjectPtr, TStrongObjectPtr for non-UObject owners, FGCObject::AddReferencedObjects, AddToRoot/RemoveFromRoot, MarkAsGarbage and IsValid checks, and the non-UObject smart pointers TSharedPtr/TSharedRef/TWeakPtr/TUniquePtr and MakeShared. Use when choosing a pointer or ownership type, debugging crashes after garbage collection, investigating dangling pointer or use-after-free bugs, holding UObjects from non-UObject classes, or picking between TSharedPtr and TUniquePtr for plain C++ objects.
   605 repo stars
7. ▌
   Ue Save And Load · kevinpbuckley bundle

   Persist and restore game data in Unreal C++ using the SaveGame system — define a USaveGame subclass with UPROPERTY members, create/save/load/delete named slots via UGameplayStatics (SaveGameToSlot, LoadGameFromSlot, AsyncSaveGameToSlot, AsyncLoadGameFromSlot, DoesSaveGameExist, DeleteGameInSlot), and serialize actor state into a byte buffer with FMemoryWriter/FMemoryReader and FObjectAndNameAsStringProxyArchive. Covers the SaveGame UPROPERTY specifier and ArIsSaveGame archive flag for selective actor serialization, the ULocalPlayerSaveGame subclass for per-user saves, save versioning and migration, ISaveGameSystem platform abstraction, and design rules for what belongs in a save. Use when implementing save/load, persisting progress, inventory, or settings, handling multiple save slots or user profiles, serializing dynamic actor state, migrating old saves, or troubleshooting missing fields and null returns on load.
   605 repo stars
8. ▌
   Ue Umg And Slate · kevinpbuckley bundle

   UMG & Slate
   605 repo stars
9. ▌
   Ue Enhanced Input · kevinpbuckley bundle

   Implement player input with Unreal's Enhanced Input system — UInputAction (data asset, value types Boolean/Axis1D/Axis2D/Axis3D), UInputMappingContext (key-to-action mappings with per-key modifiers and triggers), UEnhancedInputComponent (BindAction with ETriggerEvent), UEnhancedInputLocalPlayerSubsystem (AddMappingContext/RemoveMappingContext), UInputModifier (Negate, SwizzleAxis, DeadZone, Scalar, Smooth), UInputTrigger (Pressed, Released, Hold, Tap, Pulse, ChordedAction), FInputActionValue (Get<bool>(), Get<float>(), Get<FVector2D>(), Get<FVector>()), and PlayerController/Pawn setup. Use when setting up player controls, binding movement/look/jump/interact actions in C++, adding or swapping mapping contexts at runtime (on-foot vs. in-vehicle vs. menu), reading analog values, or migrating from legacy BindAxis/BindAction input.
   605 repo stars
10. ▌
    Ue Animation System · kevinpbuckley bundle

    Animate skeletal meshes in Unreal using the AnimInstance / Animation Blueprint model — C++ UAnimInstance base class (NativeInitializeAnimation, NativeUpdateAnimation, NativeThreadSafeUpdateAnimation), AnimGraph with state machines and blend spaces, animation assets (UAnimSequence, UBlendSpace, UAnimMontage, UAnimComposite, UPoseAsset), anim notifies and notify states, montage playback and delegates, linked anim layers, Motion Matching (Pose Search plugin), and Motion Warping. Use when setting up character animation, driving locomotion blends from C++, playing montages for actions, firing gameplay events at precise animation frames (notifies), switching animation sets at runtime, or integrating the Pose Search / Motion Warping plugins.
    605 repo stars
11. ▌
    Ue Asset Management · kevinpbuckley bundle

    Reference and load Unreal assets correctly — hard vs soft references (TObjectPtr vs TSoftObjectPtr/TSoftClassPtr), virtual content paths, FSoftObjectPath, async loading with FStreamableManager and FStreamableHandle, the Asset Registry for querying without loading, ConstructorHelpers::FObjectFinder, UAssetManager/primary data assets, and asset bundles. Use when choosing a reference type, fixing load hitches or cook/memory bloat from hard references, loading assets on demand (level streaming, DLC, runtime content), enumerating or filtering assets without loading, or setting up a managed primary-asset pipeline with UPrimaryDataAsset.
    605 repo stars
12. ▌
    Ue Coding Standards · kevinpbuckley bundle

    Write Unreal C++ that conforms to Epic's coding standard — type prefixes (U/A/F/E/I/T/S), PascalCase naming, the bBool prefix, enum class style, Allman braces, tab indentation, const correctness, nullptr/override/final usage, TEXT() string literals, include order with generated.h last, IWYU and forward declarations, API export macros (MODULE_API), UPROPERTY/UFUNCTION specifiers with Category, TObjectPtr for UObject members, and engine types over std containers. Use when writing or reviewing any UE C++, naming types or members, structuring headers, or making code consistent with the engine and surrounding project code.
    605 repo stars
13. ▌
    Ue Cpp Fundamentals · kevinpbuckley bundle

    Write correct Unreal Engine C++ using the UObject reflection system — UCLASS/USTRUCT/ UENUM/UINTERFACE macros, UPROPERTY and UFUNCTION specifiers, GENERATED_BODY, the *.generated.h pipeline, class prefixes (U/A/F/E/I), module API export macros, the Class Default Object (CDO), NewObject vs CreateDefaultSubobject, garbage-collection-safe ownership, and UClass vs UScriptStruct internals. Use when authoring or editing any UE C++ class, exposing members or functions to Blueprints or replication, fixing UHT/reflection build errors, or choosing between pointer and ownership types.
    605 repo stars
14. ▌
    Ue Timers And Async · kevinpbuckley bundle

    Schedule and defer work in Unreal C++ — FTimerManager (SetTimer with FTimerHandle, looping and one-shot timers, SetTimerForNextTick, ClearTimer, PauseTimer/UnPauseTimer, timer delegates with payloads), async work (Async/EAsyncExecution, AsyncTask/ENamedThreads, TFuture/TPromise, FNonAbandonableTask/FAutoDeleteAsyncTask/FAsyncTask, FRunnable/FRunnableThread, the UE Tasks System UE::Tasks::Launch/FTask/FPipe), FTSTicker for non-actor ticking, thread-safety and game-thread marshaling, latent actions overview. Use when implementing a delay or repeating callback, replacing per-frame Tick with a periodic timer, deferring one frame, offloading CPU-heavy work to a background thread, or building a non-actor ticker. Cross-references ue-actors-and-components (EndPlay cleanup) and ue-delegates-and-events.
    605 repo stars
15. ▌
    Ue AI And Navigation · kevinpbuckley bundle

    Build AI in Unreal — AIController-driven pawns, Behavior Trees and Blackboards (tasks, decorators, services), the navigation system and NavMesh (MoveTo pathfinding, NavMeshBoundsVolume, NavAreas, avoidance), the Environment Query System (EQS generators, tests, C++ FEnvQueryRequest), AI Perception (sight/hearing/damage senses, ConfigureSense, OnTargetPerceptionUpdated), and StateTree (UStateTreeAIComponent). Use when creating enemy/NPC behavior, pathfinding/movement to targets, decision-making logic, environment queries for cover/flanking/positions, sensing the player, or replacing Behavior Trees with StateTree.
    605 repo stars
16. ▌
    Ue Importing Content · kevinpbuckley bundle

    Import external assets into Unreal using the Interchange framework (UInterchangeManager, UInterchangePipelineBase, UInterchangeFactoryBase, UInterchangeTranslatorBase, UInterchangeSourceData) and the legacy FBX pipeline (UFbxFactory / UnFbx::FFbxImporter). Covers the three-stage Interchange pipeline (translate → pipeline → factory), pipeline stacks, format support (FBX, glTF/GLB, OBJ, USD, images, audio), mesh and texture import settings (units/axes, normals, lightmap UVs, Nanite, sRGB/compression), skeletal mesh skeleton assignment, import asset data (UInterchangeAssetImportData / UAssetImportData), and programmatic runtime import via C++, Blueprint, and Python. Use when importing DCC content, troubleshooting wrong scale/rotation/shading after import, scripting automated batch import, customising an import pipeline, or setting up a repeatable reimport workflow.
    605 repo stars
17. ▌
    Ue Physics And Chaos · kevinpbuckley bundle

    Implement collision, physics simulation, and world queries using Unreal's Chaos physics engine in C++ — collision channels (ECollisionChannel), response types (ECollisionResponse / ECR_Block/Overlap/Ignore), collision presets and profiles, query vs physics collision (ECollisionEnabled), FBodyInstance damping/mass, SetSimulatePhysics, AddForce/AddImpulse, line traces and shape sweeps (LineTraceSingleByChannel, SweepSingleByChannel, OverlapMultiByChannel), FHitResult/FCollisionQueryParams, hit and overlap events (OnComponentHit, OnComponentBeginOverlap), physical materials (UPhysicalMaterial friction/restitution), ragdoll via UPhysicsAsset, and physics constraints (FConstraintInstance, UPhysicsConstraintComponent). Use when setting up what collides with what, creating trigger volumes, doing line/shape traces for aiming or interaction, simulating rigid-body objects, applying forces or impulses, building ragdolls, constraining bodies, or debugging missing hit/overlap events.
    605 repo stars
18. ▌
    Ue Project Structure · kevinpbuckley bundle

    Project structure
    605 repo stars
19. ▌
    Ue Control Rig And Ik · kevinpbuckley bundle

    Procedural animation and inverse kinematics in Unreal Engine — Control Rig (RigVM-based graph that manipulates a bone/control hierarchy), IK Rig (solver definitions with Full-Body IK, Limb IK, Set Transform), the IK Retargeter (transfers animation between skeletons of different proportions), and lightweight AnimGraph IK nodes (Two Bone IK, FABRIK, CCDIK). Use when implementing foot placement on terrain, hand/weapon IK, look-at, procedural pose fixups, runtime retargeting, or sharing an animation library across characters with different skeletons. Covers UControlRig, URigHierarchy, FRigUnit, UIKRigDefinition, UIKRetargeter, FAnimNode_ControlRig, FAnimNode_IKRig, FAnimNode_RetargetPoseFromMesh, FIKRigGoal, UControlRigComponent, UIKRigComponent.
    605 repo stars
20. ▌
    Ue Data Driven Design · kevinpbuckley bundle

    Drive Unreal gameplay from externally-editable data instead of hardcoded values — DataTables (UDataTable, FTableRowBase, CSV/JSON import, UCompositeDataTable), DataAssets (UDataAsset, UPrimaryDataAsset with AssetManager), Curves (UCurveFloat, UCurveTable, FRuntimeFloatCurve), config-driven UPROPERTY(config) in .ini files, and DeveloperSettings (UDeveloperSettings) for project-wide tuning. Use when defining item/enemy/level/balance schemas, choosing the right data container, exposing designer-tunable values, replacing magic numbers with editable assets, or layering data across DLC/platforms with composite tables.
    605 repo stars
21. ▌
    Ue Gameplay Framework · kevinpbuckley bundle

    Implement Unreal's gameplay framework in C++ — GameInstance, AGameModeBase/AGameMode, AGameStateBase/AGameState, APlayerController, APawn/ACharacter, APlayerState, and AHUD — including the server-only spawn/login flow, possession, controller-pawn lifecycle, and which class each piece of logic belongs in. Use when setting up game rules, default pawn/controller classes, player login/spawn/possession, replicated game or player state, match-state machines, respawn logic, or deciding "where does this code live?"
    605 repo stars
22. ▌
    Ue Lighting And Lumen · kevinpbuckley bundle

    Light Unreal scenes in C++ and configure them correctly — light component types (UDirectionalLightComponent, UPointLightComponent, USpotLightComponent, URectLightComponent, USkyLightComponent), mobility (Static/Stationary/Movable) and its impact on GI, baking, and runtime cost, Lumen global illumination and reflections (enabling, quality settings, hardware vs software ray tracing), Virtual Shadow Maps, sky and atmosphere (USkyAtmosphereComponent, UExponentialHeightFogComponent), post process volumes for exposure/auto-exposure and Lumen overrides, and reflection captures. Use when creating or configuring light components in C++, choosing light mobility, enabling or troubleshooting Lumen GI/reflections, setting up sky/fog/atmosphere, tuning exposure or color grading, placing reflection captures, or deciding between baked and dynamic lighting.
    605 repo stars
23. ▌
    Ue Plugins And Modules · kevinpbuckley bundle

    Create, structure, and manage Unreal Engine plugins — the .uplugin descriptor (FileVersion, Modules array, CanContainContent, EnabledByDefault, Plugins dependencies), plugin folder layout (Source/Content/Resources), EHostType module types (Runtime, Editor, Developer, UncookedOnly, ServerOnly, ClientOnly) and ELoadingPhase values, IModuleInterface StartupModule/ShutdownModule, IPluginManager/IPlugin runtime queries, content-only plugins, engine vs project plugins, explicit-load plugins, plugin dependency hierarchy, and packaging for distribution. Use when creating a reusable plugin, deciding plugin vs project module, structuring an editor or runtime plugin, wiring plugin module C++, enabling plugins in a project, or troubleshooting a plugin that won't load or whose content won't mount.
    605 repo stars
24. ▌
    Ue Audio And Metasounds · kevinpbuckley bundle

    Play and control audio in Unreal — the sound asset types (SoundWave, SoundCue, MetaSound Source), playing 2D/3D sounds from C++ (UGameplayStatics, UAudioComponent), spatial attenuation, sound classes/submixes/concurrency for mixing, runtime MetaSound parameters, Quartz beat-quantized playback, and the MetaSound Builder API. Use when playing SFX/music, attaching looping sounds to actors, setting up 3D spatialization, mixing/ducking audio, driving procedural audio with MetaSounds, or debugging silent sounds, voice spam, or parameter mismatches.
    605 repo stars
25. ▌
    Ue Debugging Techniques · kevinpbuckley bundle

    Debug Unreal C++ and gameplay code — native debugger usage (VS/Rider, natvis, Live Coding caveats), DrawDebug* world-space helpers (DrawDebugLine, DrawDebugSphere, DrawDebugString, etc.), on-screen messages (GEngine->AddOnScreenDebugMessage), the Visual Logger (UE_VLOG*, timestamped replay of spatial/temporal events), the Gameplay Debugger (FGameplayDebuggerCategory, custom categories), ensure/check as debugging aids, and stat/console commands for runtime interrogation. Use when diagnosing wrong behavior, visualizing traces/ranges/AI state in the world, reproducing intermittent or AI bugs with timeline replay, stepping through a crash, or adding in-game debug overlays to a custom system.
    605 repo stars
26. ▌
    Ue Delegates And Events · kevinpbuckley bundle

    Wire up callbacks and events in Unreal C++ using delegates — single-cast (DECLARE_DELEGATE, DECLARE_DELEGATE_RetVal, payload variables), multicast (DECLARE_MULTICAST_DELEGATE, DECLARE_TS_MULTICAST_DELEGATE), and dynamic (DECLARE_DYNAMIC_MULTICAST_DELEGATE, BlueprintAssignable, AddDynamic, RemoveDynamic). Covers all binding forms (BindUObject, AddUObject, BindLambda, AddWeakLambda, BindRaw, AddSP), execution (Execute, ExecuteIfBound, Broadcast), FDelegateHandle lifetime management, safe unbinding, and DECLARE_EVENT. Use when implementing the observer pattern, exposing C++ events to Blueprints, decoupling game systems, binding overlap/hit/ability callbacks, or debugging delegate crashes and silent no-ops.
    605 repo stars
27. ▌
    Ue Nanite And Rendering · kevinpbuckley bundle

    Configure Nanite virtualized geometry (FMeshNaniteSettings on static and skeletal meshes, fallback mesh, displacement/tessellation, WPO distance threshold) and reason about the broader UE rendering pipeline — deferred vs forward, GPU Scene instancing, Virtual Shadow Maps, Virtual Textures, TSR/temporal upscaling, post-process (FPostProcessSettings), scene capture to render targets, and key r.* cvars. Use when enabling Nanite on a mesh, diagnosing Nanite support failures, choosing anti-aliasing or upscaling method, configuring post-process in code or volumes, rendering to a texture (minimap, mirror, portal), tuning scalability cvars, or understanding the deferred/forward rendering split.
    605 repo stars
28. ▌
    Ue Actors And Components · kevinpbuckley bundle

    Build and compose gameplay objects from Actors and Components in Unreal C++ — the AActor lifecycle (constructor, PostInitializeComponents, BeginPlay, Tick, EndPlay, Destroyed), the component types (UActorComponent, USceneComponent, UPrimitiveComponent), the root component and attachment, spawning actors and creating/registering components at construction or runtime, and ticking. Use when creating an actor or component, setting up a component hierarchy, attaching components, spawning actors, registering runtime components, or debugging lifecycle/ticking/ attachment/overlap issues.
    605 repo stars
29. ▌
    Ue Landscape And Foliage · kevinpbuckley bundle

    Terrain, instanced vegetation, and procedural environment generation in Unreal C++ — ALandscape / ALandscapeProxy / ULandscapeComponent (heightmap grid, material layers, edit layers, splines, Nanite landscape), UFoliageType / AInstancedFoliageActor / UHierarchicalInstancedStaticMeshComponent (HISM-backed instanced foliage, procedural foliage volumes), and the PCG framework (UPCGComponent / UPCGGraph, point data, landscape sampling, runtime generation). Use when creating or sculpting terrain, painting weight layers or foliage, adding landscape splines, batching vegetation with HISM, authoring PCG graphs, querying landscape data from C++, or debugging instancing and PCG generation issues.
    605 repo stars
30. ▌
    Ue Materials And Shaders · kevinpbuckley bundle

    Author and drive Unreal materials — UMaterial (the node graph asset), material instances (UMaterialInstanceConstant for editor-authored variants, UMaterialInstanceDynamic for runtime parameter changes), material domain (Surface/Deferred Decal/Light Function/Post Process/UI/Volume), shading models (Default Lit/Unlit/Subsurface/Clear Coat/Hair/Cloth/Eye), blend modes (Opaque/Masked/Translucent/Additive), scalar/vector/texture parameters, material functions, material parameter collections (global scene-wide values), and the material C++ API (CreateDynamicMaterialInstance, SetScalarParameterValue, SetVectorParameterValue, SetTextureParameterValue, UKismetMaterialLibrary). Use when creating materials, making parameterized variants, changing material parameters at runtime, setting global weather or world-state parameters, fixing material shader permutation count or translucency overdraw, or cross-referencing the material class hierarchy.
    605 repo stars
31. ▌
    Ue Mover Movement System · kevinpbuckley bundle

    Implement actor movement with Unreal's experimental Mover plugin (UE 5.8) — the modular, rollback-networked successor to CharacterMovementComponent. Covers UMoverComponent / UCharacterMoverComponent setup, producing input via IMoverInputProducerInterface and FCharacterDefaultInputs, movement modes and transitions, layered moves, instant movement effects, movement modifiers (stance/crouch), shared settings (UCommonLegacyMovementSettings), sync state queries, and backend selection (Network Prediction, Chaos networked physics, standalone). Use when adopting or evaluating Mover, creating a Mover-based pawn, authoring a custom movement mode or layered move, migrating from CMC, wiring Enhanced Input into ProduceInput, or debugging Mover prediction/rollback behavior.
    605 repo stars
32. ▌
    Ue Uds Time · kevinpbuckley

    Control Time of Day on Ultra Dynamic Sky — setting/animating time, day/night cycles, the runtime functions (Set Time with Time Code, Set Time of Day with String, Transition Time of Day), the getter functions (Get Time of Day, Get Time Code, Get Date Time, Is It Daytime), and the event dispatchers (Sunrise, Sunset, Midnight, Hourly, Current Hour Changed, Every Minute, Custom Time). Use any time the user asks about time-of-day cycles, day/night transitions, animating time, triggering events at sunrise/sunset/midnight, displaying a clock, setting time programmatically, time speed / Day Length / Night Length, or syncing game events to the in-game time — even if they don't mention UDS in a project that already uses it.
    605 repo stars
33. ▌
    Ue Automation And Testing · kevinpbuckley bundle

    Write and run automated tests for Unreal Engine projects — simple/complex automation tests (IMPLEMENT_SIMPLE_AUTOMATION_TEST, IMPLEMENT_COMPLEX_AUTOMATION_TEST), BDD-style Spec tests (DEFINE_SPEC, BEGIN_DEFINE_SPEC, Describe/It/BeforeEach/AfterEach), functional in-level tests (AFunctionalTest), low-level tests (Catch2-based LLTs), latent/async commands, EAutomationTestFlags, FAutomationTestBase assertion API (TestTrue/TestEqual/TestNotNull/AddError), and running tests from the editor, CLI, or CI. Use when writing unit or integration tests for gameplay logic or systems, setting up headless CI test runs, verifying data/content, or catching regressions.
    605 repo stars
34. ▌
    Ue Blueprint Fundamentals · kevinpbuckley bundle

    Understand Blueprints as Unreal's visual scripting and asset-class system — what a Blueprint class is, the UBlueprint editor asset vs. UBlueprintGeneratedClass runtime class, how it relates to its C++ parent, the graph types (Event Graph, Functions, Construction Script, Macros, Interfaces), variables and categories, components in Blueprint, and the C++-base + Blueprint-subclass workflow. Use when reasoning about Blueprint vs C++ responsibilities, designing a class hierarchy that spans both, explaining how Blueprint logic maps onto the underlying C++/UObject model, or debugging Blueprint compilation and class-relationship issues.
    605 repo stars
35. ▌
    Ue Character And Movement · kevinpbuckley bundle

    Implement player/AI characters in Unreal C++ with ACharacter and UCharacterMovementComponent — capsule/mesh setup, movement modes (walking/falling/flying/swimming/custom), rotation behaviors, jumping, crouching, root motion sources, client-predicted networked movement, and the experimental Mover plugin successor. Use when creating or configuring a Character class, setting movement speeds/gravity/air-control, overriding a custom movement mode (PhysCustom), adding root motion, or debugging network smoothing and prediction on a character.
    605 repo stars
36. ▌
    Ue Logging And Assertions · kevinpbuckley bundle

    Add structured logging and runtime checks to Unreal C++ — UE_LOG with custom log categories (DECLARE_LOG_CATEGORY_EXTERN/DEFINE_LOG_CATEGORY), all seven verbosity levels (Fatal/Error/Warning/Display/Log/Verbose/VeryVerbose), structured named-field logging with UE_LOGFMT, the assertion families check/checkf (halts, compiled out in shipping), verify/verifyf (expression always evaluates), ensure/ensureMsgf/ensureAlways (non-fatal, reports once), and the FMsg/FDebug helpers. Use when adding diagnostics to gameplay or engine code, defining a dedicated log category for a module or feature, choosing between crashing and recovering on a bad assumption, printing transient values to screen during PIE, filtering log output by category, or debugging shipping-only crashes where ensures would help.
    605 repo stars
37. ▌
    Ue Game Thread Performance · kevinpbuckley

    Explain how game-thread time drives frame rate and how to optimize it. Use when profiling CPU-bound frame-time spikes, tick-heavy actors, hitches, or when deciding whether to move work off the game thread.
    605 repo stars
38. ▌
    Ue Gameplay Ability System · kevinpbuckley bundle

    Build abilities, attributes, and effects with Unreal's Gameplay Ability System (GAS) — UAbilitySystemComponent (ASC), UGameplayAbility with ActivateAbility/CommitAbility/EndAbility, UAttributeSet with FGameplayAttributeData and ATTRIBUTE_ACCESSORS macro, UGameplayEffect with Instant/HasDuration/Infinite policies and GE Components, FGameplayAbilitySpec for granting, UAbilityTask for async steps (WaitDelay, PlayMontageAndWait, WaitGameplayEvent), GameplayCues for networked VFX/SFX, instancing policies (InstancedPerActor/InstancedPerExecution), net execution policies (LocalPredicted/ServerOnly), and replication modes (Full/Mixed/Minimal). Use when implementing abilities with cooldowns/costs/tags, health/stamina/mana attributes, buffs/debuffs/ damage via Gameplay Effects, ability tasks for async gameplay, Gameplay Cues for cosmetic feedback, or networked server-authoritative ability activation with client prediction. GAS requires the GameplayAbilities plugin and AbilitySystemGlobals initialization.
    605 repo stars
39. ▌
    Ue Module And Build System · kevinpbuckley bundle

    Modules & the build system
    605 repo stars
40. ▌
    Ue Uds Clouds · kevinpbuckley

    Configure clouds in Ultra Dynamic Sky — Volumetric, Static, 2D Dynamic, Voxel clouds, plus Cloud Movement, Cloud Wisps, the Volumetric Cloud Painter, Volumetric Cloud Light Rays, and the Cloud Profile Authoring Tool. Use this skill any time the user mentions clouds in UDS — appearance, altitude, scale, performance, second cloud layer, painting coverage, hard mesh intersections, blurry/streaky when moving fast, looking dark, custom cloud shapes, cloud direction/speed, looping clouds, the wispy high-altitude texture, light rays through clouds, or making a custom static cloud texture. Trigger even when the user just says "the clouds" without naming the system.
    605 repo stars
41. ▌
    Ue Navigating Engine Source · kevinpbuckley bundle

    Locate, read, and cite exact Unreal Engine APIs in the on-disk engine source instead of guessing. Use when you need a real function signature, class hierarchy, UPROPERTY/UFUNCTION specifier, module name, or include path; when verifying that an API exists in UE 5.8; when resolving "which module do I add to Build.cs?"; or when an API changed between engine versions. Covers the full source tree layout (Runtime/Editor/ Developer/Plugins), the Public/Private/Classes folder convention, UHT-generated files, naming prefixes as navigation hints, IWYU include rules, and repeatable search patterns for finding any class, function, or type from first principles.
    605 repo stars
42. ▌
    Ue Packaging And Deployment · kevinpbuckley bundle

    Cook, package, and ship an Unreal project — the cook process (by-the-book vs on-the-fly, cook rules, always/never cook directories, shader sharing), build configurations (Debug/DebugGame/Development/Test/Shipping) and build targets (Game/Client/Server/Editor) declared in *.Target.cs files, UAT BuildCookRun command-line pipeline, pak files and the modern IoStore (.utoc/.ucas) container format, asset chunking and Primary Asset Rules for DLC/patching, ProjectPackagingSettings (bUseIoStore, bGenerateChunks, bCompressed, DirectoriesToAlwaysCook/NeverCook), platform targets, content-on-demand / IoStore On-Demand, and shipping-vs-development behavioral differences (WITH_EDITOR, stripped checks/logs). Use when producing a runnable build, automating cook/package in CI, diagnosing packaging failures, configuring what ships, or setting up chunked DLC delivery.
    605 repo stars
43. ▌
    Ue Sequencer And Cinematics · kevinpbuckley bundle

    Create and drive Unreal Engine cinematics from C++ — ULevelSequence (the cinematic asset), ALevelSequenceActor (the level-placed container), ULevelSequencePlayer (CreateLevelSequencePlayer, Play, Stop, PlayLooping, SetPlaybackPosition, OnFinished), possessables vs spawnables, runtime binding overrides (SetBinding/SetBindingByTag), track and MovieScene concepts, Cine Camera (UCineCameraComponent, ACineCameraActor — filmback, focal length, aperture, focus), Camera Cuts track, and Movie Render Queue for high-quality offline output. Use when triggering or controlling a cutscene at runtime, overriding sequence bindings for dynamic actors, reacting to sequence-end events, animating a film-style camera, firing gameplay callbacks from an event track, or rendering frames with the Movie Render Pipeline.
    605 repo stars
44. ▌
    Ue Blueprint Cpp Integration · kevinpbuckley bundle

    Expose C++ classes, functions, and properties to Blueprint in Unreal Engine — UFUNCTION specifiers (BlueprintCallable, BlueprintPure, BlueprintImplementableEvent, BlueprintNativeEvent), UPROPERTY exposure (BlueprintReadWrite/ReadOnly, EditAnywhere/DefaultsOnly, ExposeOnSpawn), UCLASS specifiers (Blueprintable, BlueprintType), meta=(...) tags, Blueprint function libraries, TSubclassOf/soft references, and Blueprint-implementable interfaces. Use when deciding which specifiers to put on C++ members or functions, designing a designer-facing API, calling between C++ and Blueprint, or debugging missing nodes/properties/events in the Blueprint graph.
    605 repo stars
45. ▌
    Ue Core Types And Containers · kevinpbuckley bundle

    Core types & containers
    605 repo stars
46. ▌
    Ue Levels And World Partition · kevinpbuckley bundle

    Structure and stream Unreal worlds in C++ — UWorld (persistent level + streaming levels), ULevel, ULevelStreaming; World Partition (UWorldPartition, runtime spatial-hash grid, UWorldPartitionRuntimeCell, streaming sources/UWorldPartitionStreamingSourceComponent); Data Layers (UDataLayerAsset, UDataLayerInstance, UDataLayerManager, EDataLayerRuntimeState); Level Instances (ALevelInstance, APackedLevelActor); One File Per Actor (OFPA); legacy sublevel streaming (UGameplayStatics::LoadStreamLevel / UnloadStreamLevel, Level Streaming Volumes). Use when organizing a level, building open-world or large-level streaming, toggling content sets (day/night, quest states) at runtime, creating reusable instanced level chunks, or choosing between World Partition and explicit sublevels.
    605 repo stars
47. ▌
    Ue Meshes Static And Skeletal · kevinpbuckley bundle

    Work with static and skeletal meshes in Unreal C++ — UStaticMesh + UStaticMeshComponent, USkeletalMesh + USkeletalMeshComponent + USkinnedMeshComponent, instanced meshes (ISM/HISM), material slots (SetMaterial/GetMaterial), sockets (static and skeletal), collision setup (UBodySetup, ECollisionTraceFlag, simple vs complex), the Skeleton/PhysicsAsset relationship, Nanite enable flag on static and skeletal meshes, LODs, and mesh sections. Use when assigning or swapping meshes in C++, configuring collision, enabling Nanite, choosing ISM vs HISM vs individual components, attaching to mesh sockets, overriding material slots, querying LOD data, or debugging missing materials, wrong skeleton, or silent socket attachment failures.
    605 repo stars
48. ▌
    Ue Networking And Replication · kevinpbuckley bundle

    Implement server-authoritative multiplayer in Unreal C++ — network roles and authority (HasAuthority, GetLocalRole, GetRemoteRole, ROLE_Authority/AutonomousProxy/SimulatedProxy), actor replication setup (bReplicates, SetReplicates, bAlwaysRelevant, NetDormancy, NetUpdateFrequency), property replication (UPROPERTY Replicated/ReplicatedUsing, GetLifetimeReplicatedProps, DOREPLIFETIME/DOREPLIFETIME_CONDITION/DOREPLIFETIME_WITH_PARAMS), RepNotify callbacks (OnRep_), RPCs (UFUNCTION Server/Client/NetMulticast, Reliable/Unreliable, WithValidation, _Implementation/_Validate), replication conditions (COND_*), Push Model (MARK_PROPERTY_DIRTY_FROM_NAME, FDoRepLifetimeParams::bIsPushBased), FFastArraySerializer, and the Iris replication system. Use when replicating state across clients, adding RPCs, fixing multiplayer authority bugs, choosing replication conditions, or diagnosing "works in single player but not multiplayer" issues.
    605 repo stars
49. ▌
    Ue Profiling And Optimization · kevinpbuckley bundle

    Profile and optimize Unreal Engine performance — Unreal Insights (trace-based CPU/GPU/memory profiling, .utrace sessions, Timing Insights, Memory Insights), stat commands (stat unit/fps/game/gpu/scenerendering/memory and the full stat command table), stat groups, C++ instrumentation (DECLARE_STATS_GROUP, DECLARE_CYCLE_STAT, SCOPE_CYCLE_COUNTER, QUICK_SCOPE_CYCLE_COUNTER, TRACE_CPUPROFILER_EVENT_SCOPE, CSV_SCOPED_TIMING_STAT), memory profiling (LLM, MemReport, memreport -full), and the measurement-first optimization workflow. Use when diagnosing frame-rate drops, hitches, CPU/GPU bottlenecks, or memory growth, when adding timing instrumentation to find a hotspot, or when deciding on CPU vs GPU vs memory optimization levers.
    605 repo stars
50. ▌
    Ue Editor Scripting And Python · kevinpbuckley bundle

    Automate and extend the Unreal Editor using Python (the `unreal` module, startup scripts, commandlets), Editor Utility Widgets/Blueprints (Blutility — UEditorUtilityWidget, UEditorUtilityObject, UEditorUtilityWidgetBlueprint, UAssetActionUtility), the editor scripting subsystems (UEditorActorSubsystem, UEditorAssetSubsystem, ULevelEditorSubsystem, UAssetEditorSubsystem, UEditorUtilitySubsystem), and how C++ UFUNCTION specifiers (BlueprintCallable, CallInEditor, ScriptMethod, ScriptName) control which APIs surface in Python and Blueprints. Use when batch-processing assets, building in-editor tools or dockable UMG panels, running headless Python commandlets in CI, scripting repetitive editor tasks, or exposing custom C++ editor APIs to Python/Blueprints. Editor-only — never used in packaged games.
    605 repo stars
51. ▌
    Ue Uds Simulation · kevinpbuckley

    Use Ultra Dynamic Sky's real-world astronomical simulation — Simulate Real Sun, Simulate Real Moon, Simulate Real Stars; latitude/longitude/time zone setup; North Yaw; daylight savings; city presets; the simulation date; Simulation Speed; and Use System Time (sync with the OS clock). Use any time the user mentions real-world sun position, latitude/longitude, city presets, accurate sunrise/sunset times for a real location, real star map, real moon phases matching a date, North direction in the level, daylight savings handling, or syncing in-game time to the player's actual system clock.
    605 repo stars
52. ▌
    Ue Gameplay Architecture Planning · kevinpbuckley bundle

    Design and plan Unreal Engine gameplay systems before implementation. Turns an ambiguous feature or game idea into an Unreal-native architecture with explicit ownership, lifetime, Actor/Component/UObject/Subsystem choices, Game Framework placement, C++ versus Blueprint boundaries, communication and replication flows, data and asset models, trade-off analysis, and an ordered implementation plan. Use when brainstorming a new mechanic or system, comparing architectural approaches, deciding where logic or state should live, mapping a feature across gameplay classes, or preparing a safe task list for an implementation agent.
    605 repo stars
53. ▌
    Ue Uds Sun Moon Stars · kevinpbuckley

    Control the sun, moon, stars, aurora, sky glow, and space layer (planets/moons/nebula) in Ultra Dynamic Sky. Covers sun/moon path (Yaw, Pitch, Vertical Offset, Moon Orbit Offset), manual positioning with Sun/Moon Target widgets, sun appearance (scale/softness/color/eclipse), moon appearance and phases, Stars (tiling vs 360 starmap), 2D and Volumetric Aurora, Night Sky Glow + Light Pollution, and adding planets/moons/nebula via the Space Layer. Use whenever the user asks about sun/moon position, where the sun rises, manual sun placement, moon phases, stars not appearing, aurora effects, light pollution, or adding visible planets/moons — even phrased generally like "I want a giant moon" or "how do I get aurora borealis".
    605 repo stars
54. ▌
    Ue Uds Setup And Modes · kevinpbuckley

    How to install Ultra Dynamic Sky (UDS) in an Unreal level and pick its top-level modes — Sky Mode (Volumetric/Static/2D/Voxel/Aurora/Space), Color Mode (Sky Atmosphere vs Simplified), Project Mode (Game vs Cinematic), Feature Level (Desktop/Mobile). Use whenever the user mentions adding UDS to a scene, the UDS actor not working, choosing between cloud types, setting up the sky in a new level, mobile/console targets, or anything in the "Basic Controls" category — even when phrased generically like "why are my volumetric clouds missing on mobile", "switch to performance-friendly clouds", or "is there a space-only sky mode".
    605 repo stars
55. ▌
    Ue Uds Fog And Atmosphere · kevinpbuckley

    Configure fog, volumetric fog, dust, and atmospheric coloring in Ultra Dynamic Sky. Covers Fog Density (base + cloud/fog/dust contributions, height falloff, start distance), Fog Color (and the `Support Sky Atmosphere Affecting Height Fog` project setting), Volumetric Fog with light scattering, the Global Volumetric Material (3D noise, ground fog, water-level fog), Dust, the Sky Atmosphere settings (Rayleigh scattering, absorption, overcast luminance), and Simplified Color mode for cheaper sky shading. Use whenever the user mentions UDS fog, height fog, volumetric fog, atmospheric scattering, sky color tinting, dust/sand haze, ground fog, fog below water, or sees a "hard line where fog suddenly starts" issue.
    605 repo stars
56. ▌
    Ue Udw Setup And State · kevinpbuckley

    Set up Ultra Dynamic Weather (UDW) and control its weather state — adding UDW (requires UDS), Basic Controls (Weather preset, Wind Direction), the seven weather state values + material state, Weather Settings Presets, Change Weather, the Manual Weather State with per-value overrides, sampling weather (Get Cloud Coverage / Get Display Name for Current Weather), weather event dispatchers (Started/Finished Raining, Getting Cloudy, Weather Display Name Changed, State Change per value), and the Actor Weather Status component for per-actor exposure tracking. Use any time the user asks about adding UDW, setting up rain/snow, changing weather, presets like Blizzard or Thunderstorm, sampling weather from blueprint, weather-driven events, or per-actor exposure.
    605 repo stars
57. ▌
    Ue Udw Spatial Weather · kevinpbuckley

    Apply weather to specific regions of a level with Ultra Dynamic Weather — Weather Override Volumes (spline-defined arbitrary shape, Transition Width, Priority, Apply Wind Direction, climate preset, runtime ChangeWeather/ChangeToRandomWeatherVariation, Custom Volume Behavior), Radial Storms (circular weather actor visible from outside as a distant storm with clouds/fog/obscured lightning, spawning system, Fade In/Out, Move Over Time), Weather Above Volumetric Clouds adjustments, the Weather Mask system (Brush, Projection Box, Brush Painter editor utility) for masking material effects in interiors, and Control Point Location Source. Use any time the user asks about per-region weather, a localized storm, weather differing by area, a moving storm, a storm visible from a distance, the player driving into bad weather, weather changing above the cloud layer, or keeping snow/wetness out of an interior.
    605 repo stars
58. ▌
    Ue Uds Cinematics Rendering · kevinpbuckley

    Use Ultra Dynamic Sky for cinematic work — animating UDS with Sequencer (keyframing Time of Day, Cloud Coverage/Fog, Cloud Movement, exposing extra variables to cinematics), rendering movies with Movie Render Queue (Project Mode Cinematic/Offline), supporting the Path Tracer (`Adjust for Path Tracer`, post-process height fog approximation), and configuring volumetric clouds to seamlessly loop. Use any time the user mentions Sequencer with UDS, cinematic rendering, MRQ, path-traced renders with UDS, looping clouds for a film, or keyframing the sky/weather over time.
    605 repo stars
59. ▌
    Ue Uds Lighting And Shadows · kevinpbuckley

    Configure lighting in Ultra Dynamic Sky — Sun and Moon directional light components, Cloud Shadows (volumetric and 2D), Sky Light modes (Capture Based / Custom Cubemap / Cubemap with Dynamic Color Tinting), Exposure (auto exposure / manual), static/stationary lighting setup, Screen Space Light Shafts, the Light Day/Night Toggle component for lights that come on at night, and the day-to-night material utility functions. Use any time the user mentions UDS lighting, shadows, sky light, ambient light, sun shadow softness, light angle, exposure problems, scene rendering black or wrong at night, baked lighting with UDS, god rays/light shafts, lights that come on at sunset, cubemap recapture cost, or making a child of UDS to override sun color.
    605 repo stars
60. ▌
    Ue Uds Modifiers Configs State · kevinpbuckley

    Use UDS's higher-level state features — Sky Modifiers (data assets that override sky/post-process properties, time-of-day-triggered modifiers), the Configuration Manager (save/apply complete UDS configs, runtime Apply Sky Configuration, configuration override), Save UDS+UDW state for save games, Sun Lens Flare, Post Process Components driven by time/weather/interior, Interior Adjustments + Player Occlusion (with UDS Occlusion Volume and Portal), Water Level (caustics, underwater fog, Water Body Classes), Ambient Sound — Time and Weather Controlled, and the UDS Onscreen Controls widget (with multiplayer client controller). Use any time the user asks about saving/loading sky presets, applying a different sky config, save-game serialization for time/weather, sun lens flare, post-processing tied to time of day, indoor vs outdoor differences, water/underwater effects, ambient sounds that change with time, or an on-screen UI to control the sky.
    605 repo stars
61. ▌
    Ue Udw Random Seasons Temperature · kevinpbuckley

    Configure dynamic weather variation, seasons, climate, and temperature on Ultra Dynamic Weather. Covers Random Weather Variation (Random Interval / Daily / Hourly timing, Weather Type Probabilities, Transition Length, Begin Play Weather is Random, Change to Random Weather Variation), Seasons (0-4 float, Set Season, Season Mode driven by date, Meteorological vs Astronomical, Sample UDW Season + Season Color Blend material nodes), Climate Presets (real-world data setting probability + temperature ranges), Temperature (Get Current Temperature with F/C, Temperature Bias, Min/Max per season, Sample Location Global vs local, Interior Temperature), Temperature Volumes, and the UDW Thermometer widget. Use whenever the user asks about random weather, season cycling, climate presets, temperature reading, hot/cold zones, or what season it is.
    605 repo stars
62. ▌
    Ue Udw Material And Screen Effects · kevinpbuckley

    Add weather-responsive material effects and screen-space effects with Ultra Dynamic Weather — Surface Weather Effects (wetness/snow/dust/dripping/droplets), Dynamic Landscape Weather Effects V3 (DLWE) with the DLWE Interaction component for trails/ripples, Glass Window Rain Drips, Foliage Wind Movement, Water Surface Rain Ripples, the Sample UDW Material State / Season / Wind nodes, plus screen/environmental effects — Rainbow, Screen Droplets, Screen Frost, Heat Distortion, Post Process Wind Fog, Puddle Fluid Volume (with fluid interactions), Dripping Mesh Particles, Freezing Breath, Rain Drip Spline (with icicles), and the Weather Occlusion Volume. Use any time the user asks about materials responding to weather, footprints/tracks in snow, puddles, rain on windows, foliage sway, rain ripples on water, rainbow, screen droplets/frost, heat haze, breath in cold weather, or water dripping from a roof edge.
    605 repo stars
63. ▌
    Ue Uds Performance Mobile Troubleshooting · kevinpbuckley

    Tune Ultra Dynamic Sky for performance, configure for mobile/consoles, update UDS safely, modify it via child blueprints, and resolve common runtime issues. Covers Sky Mode perf impact, Volumetric Cloud Rendering Mode, sample scales, Two Layers, Sky Light Mode tradeoffs, Volumetric Fog scalability, Half Rate Tick, Use Sky Mode Scalability Map, Lights Update settings, the Mobile category + Platform Feature Levels map, updating UDS from the Fab launcher (default vs custom location), Static Properties functions, Hard Reset Cache, Max Property Cache Period, and fixes for black scene, ambient light not updating, slow Lumen GI adaptation, runtime property changes that take a second or don't apply, hard cloud/mesh intersections, blurry/streaky/dark clouds, hard fog lines, sky flickering black, low-quality volumetric fog, and missing Space Layer.
    605 repo stars
64. ▌
    Ue Udw Particles Lightning Wind Sounds · kevinpbuckley

    Configure Ultra Dynamic Weather's rendered effects — Rain / Snow / Dust Particles (including Splash Particles), Particle Collision modes (Simple, Distance Field, None, Kill Sphere), Shared Particle Settings, Lightning (Flashes + Obscured, Flash Lightning function, Strikable Actor Interface), Wind (Direction + variation, Debris, Gusts, Directional Source for chaos cloth/SpeedTree, Physics Force, Camera Shake), Weather Sound Effects (wind/rain/thunder + Close Thunder Delay Per KM), Sound Occlusion with UDS Occlusion Portal, and Environment Sounds (UDS_Environment_Sound data assets, 5.1 metasound format, ChangeEnvironmentSound, UDS_TimeWeather_VolumeManager). Use any time the user asks about rain/snow not visible or blocked wrong, particle collision modes, lightning striking specific actors, wind on physics/cloth, weather sounds in interiors, ambient outdoor audio, or VR splash issues.
    605 repo stars
65. ▌
    Animation Blueprint · kevinpbuckley bundle

    Navigate, inspect, and author Animation Blueprints — state machines, states, transitions, and transition rules (AnimGraphService). Use when the user asks to create or edit an Animation Blueprint/AnimBP, add a state machine or states, wire transitions between states, set a state's animation, or inspect AnimGraph structure.
    605 repo stars
66. ▌
    Landscape Materials · kevinpbuckley bundle

    Create landscape materials with layer blending, texture setup, and layer info objects (LandscapeMaterialService). Use when the user asks to build a landscape/terrain material, set up paint layers (grass/rock/dirt), create layer info objects, add a grass output, or assign a material to a landscape. For production master-material+RVT systems, load landscape-auto-material.
    605 repo stars
67. ▌
    Landscape Auto Material · kevinpbuckley bundle

    Create production-quality landscape materials with the master-material + material-function + material-instance paradigm, RVT, and auto-layering. Use when the user asks for an auto/procedural landscape material, slope/altitude/distance-based layer blending, Runtime Virtual Textures, biome configuration via instances, or layer material functions. For basic layer-blend materials load landscape-materials.
    605 repo stars
68. ▌
    Fab · kevinpbuckley

    Search Fab's public free catalog (including Quixel Megascans) and directly import eligible assets without adding them to the account library, or discover/import the signed-in Epic account's owned Fab library. Use for free Fab/Quixel searches, owned-library questions, compatibility checks, and Fab imports. No purchasing or entitlement claiming.
    605 repo stars
69. ▌
    Pcg · kevinpbuckley bundle

    Create, inspect, and edit PCG Graph assets — add nodes, configure settings, connect pins, and wire procedural generation graphs (native PCG Python API). Use when the user asks to build a PCG graph, add PCG nodes (Surface Sampler, Static Mesh Spawner, filters), wire PCG pins, place a PCGVolume and generate, or set up procedural scattering.
    605 repo stars
70. ▌
    Vibeue · kevinpbuckley

    Unreal Engine 5 development using the VibeUE Python API. Use when working in Unreal Engine — blueprints, state trees, materials, actors, landscapes, animation, niagara, widgets, sound, foliage, gameplay tags, enhanced input, skeletons, PCG (procedural content generation), and more. VibeUE is an extension of Unreal's native MCP endpoint.
    605 repo stars
71. ▌
    Foliage · kevinpbuckley bundle

    Create foliage types and place/scatter foliage instances on landscapes and meshes (FoliageService). Use when the user asks to add trees/grass/bushes/rocks as foliage, create a foliage type from a mesh, scatter or paint foliage instances, or query/remove foliage on a surface.
    605 repo stars
72. ▌
    Skeleton · kevinpbuckley bundle

    Edit skeleton bone transforms/hierarchy, retargeting modes, curve metadata, blend profiles, bone constraints, and learn constraints from animations (VibeUE SkeletonService). Socket CRUD, bone enumeration, physics-asset, and material/LOD inspection are owned by the engine SkeletalMeshTools. Use when the user asks to add/transform bones, set retargeting, manage blend profiles or curves, or set bone constraints. For animation bone edits, also load animation-editing.
    605 repo stars
73. ▌
    Viewport · kevinpbuckley bundle

    Control the Unreal Editor level viewport — camera type/position, view mode, FOV, exposure, layout, and rendering settings (ViewportService). Use when the user asks to move the editor camera, change the view mode (Lit/Unlit/Wireframe), set FOV/exposure, switch viewport layout, or frame the level for a screenshot.
    605 repo stars
74. ▌
    Landscape · kevinpbuckley bundle

    Create and edit landscape terrain — heightmaps, sculpting, paint layers, terrain analysis, mesh projection, and procedural features like mountains/valleys/craters (LandscapeService). Use when the user asks to create a landscape, sculpt/raise/lower terrain, import or export a heightmap, paint terrain layers, or add procedural terrain features. For terrain materials load landscape-materials; for real-world heightmaps load terrain-data.
    605 repo stars
75. ▌
    Materials · kevinpbuckley bundle

    Create and edit materials and material instances — graph nodes, parameters, functions, custom HLSL, and instance overrides (MaterialService + MaterialNodeService). Use when the user asks to create or edit a material/material instance, wire material nodes, add material parameters, set blend/shading modes, or recreate a material graph. For landscape materials load landscape-materials.
    605 repo stars
76. ▌
    Profiling · kevinpbuckley

    Diagnose frame-rate bottlenecks (CPU vs GPU bound FIRST), control Unreal Insights traces, sample live frame times, and annotate performance captures. Use when FPS is low/bad, the game is slow, or you need to find what is limiting the frame rate.
    605 repo stars
77. ▌
    Blueprints · kevinpbuckley bundle

    Create and modify Blueprint assets, variables, functions, components, event dispatchers, and interfaces. Use when the user asks to create a Blueprint/BP, add a variable or component to a Blueprint, make an event dispatcher/delegate, implement a Blueprint interface, or inspect a Blueprint's class/components. For node-level graph wiring, also load blueprint-graphs.
    605 repo stars
78. ▌
    Frame Rate · kevinpbuckley bundle

    Diagnose and remove FPS caps so the editor and game run uncapped (or at a target FPS). Use when the user says the editor/game is "locked", "capped", or "stuck" at a frame rate (commonly 60 FPS), asks to "unlock"/"uncap"/"raise" FPS, or wants to set a max FPS. Covers t.MaxFPS, VSync, fixed/smoothed frame rate, and background CPU throttling (EngineSettingsService).
    605 repo stars
79. ▌
    Metasounds · kevinpbuckley bundle

    Create and modify MetaSound Source assets — add/connect nodes, wire pins, set input defaults, and play procedurally (MetaSoundService). Use when the user asks to create a MetaSound, build or edit a MetaSound graph, add operator/input/output nodes, or generate procedural audio.
    605 repo stars
80. ▌
    Sound Cues · kevinpbuckley bundle

    Create and modify SoundCue assets — add/connect nodes (mixer, random, delay, attenuation, modulator, etc.) and set audio properties (SoundCueService). Use when the user asks to create a Sound Cue, build a SoundCue node graph, or wire audio playback logic.
    605 repo stars
81. ▌
    Uv Mapping · kevinpbuckley bundle

    Inspect, generate, transform, and visualize UV channels on StaticMesh assets (UVMappingService). Use when the user asks to check/add/remove UV channels, auto-unwrap UVs, transform (tile/offset/rotate) UVs, check UV health/islands, or export a UV layout image.
    605 repo stars
82. ▌
    Enum Struct · kevinpbuckley bundle

    Create, modify, and introspect UserDefinedEnums and UserDefinedStructs (EnumStructService). Use when the user asks to create a Blueprint enum or struct, add enum values or struct members, or inspect an enum/struct's fields. Useful for defining a DataTable row struct.
    605 repo stars
83. ▌
    Pie Testing · kevinpbuckley bundle

    Start, stop, and query Play-In-Editor (PIE) sessions for runtime testing of Blueprints, gameplay logic, widgets, AI, and any in-game behavior. Use when the user asks you to "play", "test", "run", "PIE", "start/stop the game", or otherwise needs a live game world to validate changes.
    605 repo stars
84. ▌
    State Trees · kevinpbuckley bundle

    Create, inspect, and edit StateTree assets — states, tasks, transitions, conditions, considerations, and property bindings for AI behavior and game logic (StateTreeService). Use when the user asks to build a StateTree, add states/tasks/transitions, bind task properties, set up Utility AI considerations, or wire StateTree delegate transitions.
    605 repo stars
85. ▌
    Umg Widgets · kevinpbuckley bundle

    Create and modify UMG Widget Blueprints (UI) — build the widget hierarchy, set properties, style fonts/brushes, author widget animations, bind events, capture previews, run PIE checks, and wire MVVM ViewModels. Use when the user asks to create a UI/HUD/menu, add or arrange widgets (Button, TextBlock, Image, panels), style or animate a widget, or set up data bindings in a Widget Blueprint (WBP).
    605 repo stars
86. ▌
    Animsequence · kevinpbuckley bundle

    Create and edit AnimSequence keyframes and tracks — add/remove keyframes, set bone tracks, query sequence info, and bake edits (AnimSequenceService). Use when the user asks to create a new animation sequence, add keyframes/tracks, or edit raw animation data. For constraint-aware bone posing, also load animation-editing.
    605 repo stars
87. ▌
    Level Actors · kevinpbuckley bundle

    List, find, place, move, rotate, and modify actors in the current level (ActorService + editor subsystems). Use when the user asks to find/list actors in the level, move or rotate an actor, set an actor's properties/folder/transform, or spawn/delete level actors.
    605 repo stars
88. ▌
    Map Blockout · kevinpbuckley bundle

    Procedurally design an AAA-style open-world FPS map blockout (roads, POIs, fields, forests/treelines, railway/bridges) from a landscape, validate it through gated checks, and materialize it into engine geometry. Use when the user asks to block out or lay out an open-world/FPS map, place roads/POIs/forests/railways procedurally, or turn a blockout plan into splines, paint layers, foliage, and actors.
    605 repo stars
89. ▌
    Terrain Data · kevinpbuckley

    Generate heightmaps, map reference images, and water feature splines (rivers, lakes, oceans) from real-world geographic data (terrain_data tool). Use when the user asks to build terrain from a real location/coordinates, download a real-world heightmap, or add rivers/lakes/oceans from map data. Downloads Mapbox tiles server-side and produces UE5-compatible heightmaps + landscape splines.
    605 repo stars
90. ▌
    Gameplay Tags · kevinpbuckley bundle

    Create, list, remove, and rename Gameplay Tags with runtime registration (GameplayTagService). Use when the user asks to add or register gameplay tags, list/query existing tags, or rename/remove tags (e.g. Ability.Attack.Melee, State.Stunned).
    605 repo stars
91. ▌
    Behavior Trees · kevinpbuckley

    Create, inspect, and edit Behavior Tree and Blackboard assets — composites, tasks, decorators, services, node properties, blackboard key bindings, key CRUD and metadata, tree round-trips and validation (BehaviorTreeService + BlackboardService). Use when the user asks to build a Behavior Tree, add BT nodes or decorators, bind blackboard keys, author a blackboard, or validate/repair a BT asset.
    605 repo stars
92. ▌
    Enhanced Input · kevinpbuckley bundle

    Create and configure Enhanced Input — Input Actions, Mapping Contexts, key mappings, triggers, and modifiers (InputService). Use when the user asks to set up player input, create an Input Action (IA_) or Input Mapping Context (IMC_), bind keys to actions, or configure input triggers/modifiers.
    605 repo stars
93. ▌
    Engine Settings · kevinpbuckley bundle

    Configure Unreal Engine core settings — rendering, physics, audio, garbage collection, console variables (cvars), and scalability levels (EngineSettingsService). Use when the user asks to change engine/rendering settings, set a console variable (r.*, etc.), adjust scalability/quality levels, or read engine config categories.
    605 repo stars
94. ▌
    Niagara Systems · kevinpbuckley bundle

    Rapid-iteration parameter tuning, diagnostics, and Custom-HLSL scratch-pad authoring for Niagara systems (VibeUE NiagaraService + NiagaraScratchPadService). System/emitter/parameter CRUD is owned by the engine NiagaraToolsets. Use when the user asks to tune emitter rapid-iteration params, compare/diagnose systems, or build scratch-pad/Custom HLSL modules. For emitter color/module work, load niagara-emitters.
    605 repo stars
95. ▌
    Asset Management · kevinpbuckley bundle

    Import/export textures crash-safely, query the Content Browser selection, and check if an asset is open (AssetDiscoveryService). Search, load, save, move, rename, duplicate, and delete assets are handled by Unreal's native AssetTools toolset or EditorAssetLibrary. Use when the user asks to import an image from disk, export a texture, query the Content Browser selection, or check whether an asset is open in an editor.
    605 repo stars
96. ▌
    Blueprint Graphs · kevinpbuckley bundle

    Add, connect, and configure nodes in Blueprint event graphs and function graphs — function-call/event/branch/timer/custom-event/delegate nodes, Standard Macro nodes (ForEachLoop/ForLoop/WhileLoop/DoOnce/Gate/IsValid/FlipFlop via add_macro_instance_node), macro-graph creation, pin wiring, node layout, arrays, comment boxes, and the batch build_graph API. Use when the user asks to wire up Blueprint logic, add or connect nodes, add a loop/macro node, build an event graph, set up a timer/delay, broadcast a delegate, or lay out an existing graph.
    605 repo stars
97. ▌
    Niagara Emitters · kevinpbuckley bundle

    Niagara emitter color/curve authoring (tint, hue-shift, ColorFromCurve keys), rapid-iteration parameter tuning, and Custom-HLSL scratch-pad authoring (NiagaraEmitterService + NiagaraScratchPadService). Module/renderer CRUD is owned by the engine NiagaraToolsets. Use when the user asks to recolor or hue-shift particles, edit color curves, tune emitter params, or build a scratch-pad/Custom HLSL module. For system-level lifecycle, load niagara-systems.
    605 repo stars
98. ▌
    Project Settings · kevinpbuckley bundle

    Configure Unreal Engine project settings and editor preferences — UI appearance, toolbar icons, scale, colors, and any UDeveloperSettings subclass (ProjectSettingsService). Use when the user asks to change a project setting or editor preference, configure a UDeveloperSettings category, or read/write project config values.
    605 repo stars
99. ▌
    Animation Editing · kevinpbuckley bundle

    Preview, validate, and bake bone-rotation edits on AnimSequences with constraint awareness and retarget safety. Use when the user asks to edit/pose/adjust an animation's bones, raise an arm, create a swing/wave/dance/pose, mirror or copy a pose, set joint limits, or learn bone constraints. Load together with animsequence (keyframes) and skeleton (structure).
    605 repo stars
100. ▌
     Animation Montage · kevinpbuckley bundle

     Create and manipulate Animation Montages — sections, slots, segments, branching points, notifies, and blend settings (AnimMontageService). Use when the user asks to create a montage (from an animation or empty), add or link montage sections, set up slots/segments, add branching points, or adjust montage blend timing.
     605 repo stars