This post exists as a quick reference guide to the most commonly used Unreal Engine 5 Blueprint nodes. Each entry provides a short, practical explanation and a few common use cases, designed to be glanced over when you need to refresh your memory on what’s available, without digging through documentation or tutorials.
Use this page as a mental index: skim the sections, jump to what you need, and get back to building.
Node categories covered:
- Flow Control
- Variables & Data Types
- Math
- Vectors & Transforms
- Input & Player
- Movement
- Actors & Components
- Collision & Traces
Event BeginPlay
Runs once when the actor enters play.
- Initialize player stats at level start
- Cache references to key actors or components
- Start timers, ambient audio, or intro logic
Event Tick
Executes every frame while the actor is active.
- Update stamina, cooldowns, or UI values
- Drive continuous movement or rotation
- Poll conditions that must be checked constantly
Delay
Pauses execution for a specified duration.
- Add cooldowns between actions
- Sequence timed events like explosions
- Wait before re-enabling input
Retriggerable Delay
Delays execution but restarts if triggered again.
- Handle charge-up or hold interactions
- Reset timers while input is active
- Detect inactivity before firing logic
Set Timer by Event
Schedules an event to execute after a delay, optionally looping.
- Replace Tick with timed or repeating logic
- Trigger cooldowns or periodic effects
- Schedule delayed or looping gameplay actions
Sequence
Executes multiple output pins in order.
- Run multiple setup steps from one event
- Split logic paths for readability
- Trigger several systems at once
Branch
Routes execution based on a boolean value.
- Check if the player can perform an action
- Validate game state before executing logic
- Handle success vs failure outcomes
Do Once
Allows execution only one time until reset.
- Prevent duplicate death or destruction logic
- Show a tutorial prompt only once
- Stop duplicate death or cutscene triggers
Do N
Allows execution a limited number of times.
- Limit interaction attempts (e.g., 3 lockpick tries)
- Cap repeated warnings (e.g., “Not enough mana”)
- Step through combo stages a fixed number of times
Gate
Blocks or allows execution based on open/closed state.
- Disable an action while on cooldown
- Allow tick-based logic only while a state is active
- Prevent input spam until a timer re-opens the gate
FlipFlop
Alternates execution between A and B each time it’s triggered.
- Toggle a flashlight on/off
- Switch between two camera views
- Alternate between two attack animations
While Loop
Loops continuously while a condition remains true.
- Run logic until a condition fails
- Poll for a state change during execution
- Process data until completion
ForLoop
Loops from a start index to an end index.
- Spawn multiple actors in sequence
- Initialize array values
- Perform repeated calculations
ForLoopWithBreak
Loops but allows early exit when a condition is met.
- Search for a specific item in a list
- Stop processing once a result is found
- Abort loops when a failure occurs
ForEachLoop
Iterates over each element in an array.
- Apply logic to every item in a collection
- Update multiple actors or components
- Validate or process array data
ForEachLoopWithBreak
Iterates over an array with the option to break early.
- Find a matching actor in a collection
- Validate items until one fails
- Stop processing after success
Switch on Int
Executes logic based on an integer value.
- Handle indexed states or steps
- Drive menu selection logic
- Control numbered phases
Switch on Name
Executes logic based on a Name value.
- Route logic by identifier
- Handle named states or tags
- Match gameplay events
Switch on String
Executes logic based on a String value.
- Handle debug commands
- Route dialogue choices
- Match input text values
Switch on Enum
Executes logic based on an enum value.
- Handle character states
- Drive AI behavior modes
- Control gameplay phases
MultiGate
Cycles through output pins across executions.
- Step through scripted events
- Rotate attack patterns
- Control staged sequences
Set Variable
Writes a value into a variable.
- Update health, ammo, or score
- Store state changes
- Save references
Get Variable
Reads the value of a variable.
- Check current player stats
- Drive UI displays
- Feed data into logic
IsValid
Checks whether an object reference exists.
- Prevent null reference crashes
- Validate spawned actors
- Guard optional logic paths
IsValid (Exec)
Branches execution based on object validity.
- Safely run logic on dynamic actors
- Skip logic when references are missing
- Protect async callbacks
Cast To
Attempts to convert an object to a specific class.
- Access class-specific variables
- Call specialized functions
- Confirm actor type
Select
Chooses between values based on condition or index.
- Pick values based on state
- Swap parameters dynamically
- Simplify branch-heavy logic
Make Literal (String / Name / Text)
Creates a constant literal value directly in the graph.
- Define fixed strings, names, or text values
- Avoid creating unnecessary variables
- Pass constant data into functions or widgets
Make Array
Creates an array from input values.
- Build temporary collections
- Pass grouped data
- Initialize lists
Make Map
Creates a key-value data structure.
- Store lookup tables
- Map IDs to values
- Organize paired data
Make Set
Creates a unique-value collection.
- Track unique actors
- Prevent duplicates
- Store membership data
Add (Int/Float)
Adds numeric values together.
- Increase scores or counters
- Accumulate damage
- Combine values
Subtract (Int/Float)
Subtracts one value from another.
- Reduce health or stamina
- Calculate differences
- Apply costs
Multiply (Int/Float)
Multiplies numeric values.
- Scale damage
- Apply modifiers
- Calculate totals
Divide (Int/Float)
Divides one value by another.
- Normalize values
- Calculate ratios
- Scale results
Clamp (Int/Float)
Limits a value within a minimum and maximum.
- Prevent stats from exceeding bounds
- Control input ranges
- Stabilize calculations
Map Range Clamped
Remaps a value from one range to another while clamping the result.
- Convert input values to gameplay-friendly ranges
- Scale UI values like progress bars
- Normalize data between different systems
Lerp (Float)
Interpolates smoothly between two float values.
- Animate UI values
- Smooth transitions
- Fade effects
Lerp (Vector)
Interpolates smoothly between two vectors.
- Move actors smoothly
- Blend positions
- Animate offsets
Lerp (Rotator)
Interpolates smoothly between two rotations.
- Smooth camera rotation
- Blend aiming directions
- Animate turns
FInterp To
Smoothly interpolates a float toward a target value over time.
- Smoothly change UI values like health or stamina
- Ease camera zoom or FOV changes
- Create natural-feeling value transitions
VInterp To
Smoothly interpolates a vector toward a target vector over time.
- Smoothly move actors to a target position
- Lerp camera or object movement
- Create eased movement without timelines
RInterp To
Smoothly interpolates a rotator toward a target rotation over time.
- Smooth camera or character rotation
- Ease aiming or turning
- Blend between orientations naturally
Abs
Returns the absolute (positive) value of a number.
- Remove negative values from calculations
- Compare distances or deltas
- Normalize directional values
Min
Returns the smaller of two values.
- Cap values based on a lower bound
- Compare timers or counters
- Clamp logic without full clamp node
Max
Returns the larger of two values.
- Enforce minimum thresholds
- Compare scores or stats
- Protect values from going too low
Nearly Equal (Float)
Checks if two float values are nearly the same within tolerance.
- Compare floats safely
- Check arrival at target values
- Avoid precision errors
Random Integer in Range
Generates a random integer between a minimum and maximum.
- Pick random enemy types
- Roll random loot outcomes
- Randomize behavior states
Random Float in Range
Generates a random float between a minimum and maximum.
- Add randomness to movement or timing
- Vary damage or effects
- Create organic variation
Make Vector
Creates a vector from X, Y, and Z values.
- Build direction or position data
- Pass movement or offset values
- Construct temporary vectors for calculations
Break Vector
Splits a vector into its X, Y, and Z components.
- Read individual position values
- Modify one axis independently
- Debug vector data
Make Rotator
Creates a rotation from Pitch, Yaw, and Roll values.
- Define camera or actor rotation
- Build rotation values from input
- Store orientation data
Break Rotator
Splits a rotator into Pitch, Yaw, and Roll values.
- Clamp or modify a single axis
- Read camera rotation values
- Debug rotation data
Make Transform
Creates a transform from location, rotation, and scale.
- Spawn actors with predefined transforms
- Pass full transform data between systems
- Store spatial state
Break Transform
Splits a transform into location, rotation, and scale.
- Read position, rotation, or scale separately
- Modify part of a transform
- Debug transform data
GetActorLocation
Returns the actor’s world position.
- Track actor position
- Use as start or end points for traces
- Feed movement or distance calculations
SetActorLocation
Sets the actor’s world position.
- Teleport actors
- Snap actors to targets
- Correct positional errors
AddActorWorldOffset
Moves the actor by an offset in world space.
- Apply smooth movement over time
- Push actors without teleporting
- Add procedural motion
GetActorRotation
Returns the actor’s world rotation.
- Read facing direction
- Drive aim or movement logic
- Debug orientation
SetActorRotation
Sets the actor’s world rotation.
- Snap actors to face targets
- Reset rotation
- Apply scripted orientation
AddActorWorldRotation
Rotates the actor by a delta rotation in world space.
- Apply smooth turning
- Rotate platforms or objects
- Add procedural rotation
GetWorldLocation (SceneComponent)
Returns the component’s world position.
- Track socket or component positions
- Use as trace origins
- Align effects or attachments
SetWorldLocation (SceneComponent)
Sets the component’s world position.
- Move attached components
- Animate component offsets
- Correct component placement
GetForwardVector
Returns the forward direction vector from a rotation.
- Move actors forward
- Fire projectiles in facing direction
- Perform directional traces
GetRightVector
Returns the right direction vector from a rotation.
- Strafe movement
- Offset actors sideways
- Build relative directions
GetUpVector
Returns the up direction vector from a rotation.
- Apply vertical offsets
- Handle climbing or flying logic
- Align effects vertically
Input Action
Fires when a mapped input action is triggered.
- Handle button presses like Interact or Fire
- Trigger abilities or interactions
- Start context-specific actions
Input Axis
Fires continuously with a value from an input axis mapping.
- Drive character movement
- Control camera rotation
- Handle analog input like triggers or sticks
Get Player Controller
Returns the player controller at a given index.
- Access input or camera control
- Set input modes or cursor state
- Communicate with player-specific logic
Get Player Pawn
Returns the pawn controlled by the player.
- Access the player character or vehicle
- Query player location or state
- Pass player reference to systems
Get Player Character
Returns the player pawn cast as a Character.
- Access character movement component
- Read character-specific variables
- Drive animation or ability logic
Get Control Rotation
Returns the controller’s view rotation.
- Aim weapons or traces
- Align camera-dependent logic
- Drive look-based interactions
Add Controller Yaw Input
Adds yaw (left/right) rotation to the controller.
- Rotate camera horizontally
- Apply mouse or stick input
- Implement look controls
Add Controller Pitch Input
Adds pitch (up/down) rotation to the controller.
- Rotate camera vertically
- Handle mouse or stick look
- Implement aiming controls
Set Input Mode (Game/UI)
Controls whether input is sent to the game, UI, or both.
- Switch between gameplay and menus
- Lock input during UI screens
- Enable mouse interaction
Set Show Mouse Cursor
Shows or hides the mouse cursor.
- Display cursor in menus
- Hide cursor during gameplay
- Toggle cursor for interaction modes
Add Movement Input
Adds directional movement input to a character.
- Move the player based on input
- Drive AI-controlled character movement
- Apply movement forces through the movement component
Jump
Makes the character attempt to jump.
- Trigger player jumps
- Handle AI jump navigation
- Start airborne movement states
Stop Jumping
Stops the jump input for a character.
- Control jump height
- Cancel jump input early
- Fine-tune platforming behavior
Launch Character
Applies an instant velocity change to a character.
- Launch characters from explosions
- Perform dash or knockback abilities
- Force character movement without input
Get Velocity
Returns the current velocity of an actor or component.
- Check movement speed
- Drive animation states
- Calculate impact or momentum
Set Max Walk Speed
Sets the maximum walking speed of a character.
- Modify sprint or slow states
- Apply movement debuffs or buffs
- Tune character movement dynamically
Set Movement Mode
Changes the character movement mode.
- Switch between walking, falling, or flying
- Handle swimming or climbing states
- Control movement behavior per state
SpawnActorFromClass
Spawns a new actor instance into the world.
- Create enemies, pickups, or props
- Spawn projectiles or effects
- Dynamically build gameplay elements
DestroyActor
Removes an actor from the world.
- Clean up temporary or expired actors
- Handle enemy deaths or object destruction
- Remove interactables after use
Get All Actors of Class
Finds all actors of a specific class in the level.
- Apply logic to all enemies or objects
- Gather references at runtime
- Perform global checks or updates
Get Actor Of Class
Finds the first actor of a specific class in the level.
- Get a singleton-like actor (manager, controller)
- Access a unique world object
- Quickly fetch a known actor
AttachToComponent
Attaches an actor or component to another component.
- Attach weapons to characters
- Parent effects to sockets
- Keep objects moving together
DetachFromActor
Detaches an actor from its parent.
- Drop held objects
- Release attached items
- Separate actors dynamically
GetComponentByClass
Returns the first component of a given class.
- Access movement, audio, or mesh components
- Query component data
- Avoid hard references in Blueprints
Add Component
Adds a component to an actor at runtime.
- Dynamically add audio or visual components
- Enable temporary functionality
- Build modular actors
Set Visibility
Shows or hides a component visually.
- Toggle meshes or effects
- Hide objects without disabling logic
- Control visual feedback
Set Hidden In Game
Hides a component during gameplay.
- Disable visuals without editor impact
- Hide objects for gameplay reasons
- Control runtime visibility
Set Collision Enabled
Enables or disables collision on a component.
- Turn off collision for destroyed objects
- Temporarily disable interaction
- Control physics and overlap behavior
Set Collision Response To Channel
Sets how a component responds to a collision channel.
- Configure interaction rules
- Adjust hit or overlap behavior
- Customize physics responses
OnActorBeginOverlap
Fires when another actor begins overlapping this actor.
- Detect player entering a trigger area
- Start interaction or pickup logic
- Activate area-based gameplay events
OnActorEndOverlap
Fires when another actor stops overlapping this actor.
- Detect player leaving a trigger area
- Reset interaction states
- Disable area-based effects
OnComponentBeginOverlap
Fires when another component begins overlapping this component.
- Detect precise collision on specific components
- Trigger pickups or damage volumes
- Handle component-level interactions
OnComponentEndOverlap
Fires when another component stops overlapping this component.
- End component-based interactions
- Reset trigger states
- Clean up temporary effects
OnComponentHit
Fires when a component hits another object with blocking collision.
- Detect projectile impacts
- Trigger physics-based reactions
- Apply damage on collision
LineTraceByChannel
Casts a ray and returns the first hit using a collision channel.
- Implement interaction or use traces
- Perform weapon hit detection
- Check line of sight or visibility
LineTraceForObjects
Casts a ray that checks against specific object types.
- Detect specific gameplay objects
- Filter hits by object category
- Implement targeted interaction checks