Unreal Engine Blueprints Tutorial for Beginners

Blueprints are Unreal Engine's visual scripting system. Instead of typing code, you connect boxes called nodes with wires to tell the game what to do. They are powerful enough for complete games and they are the fastest way to start. This tutorial explains events, variables, branches and how Blueprints talk to each other. Then you build a key pickup and a door that only opens when you hold the key.

What are Blueprints?

A Blueprint is a visual script. Each box in it is a node: one action, such as "play a sound" or "destroy this actor". You join nodes with wires, and the game runs them in order. Epic describes Blueprints as a complete gameplay scripting system, and many released indie games use little else.

You will meet a few kinds of Blueprints:

• Blueprint Class: a reusable object, such as a door, a coin or an enemy. You can place as many copies as you like. This is the one you use most.
• Level Blueprint: one script that belongs to a single level, handy for one-off events like a cutscene trigger.
• Widget Blueprint: on-screen interface such as a health bar or a menu.
• Blueprint Interface: a list of shared actions that different Blueprints can each handle in their own way. You will use one later.

White wires carry execution, meaning the order things happen. Colored wires carry data, such as a number or a reference to an actor. The color tells you the type: red for true or false values and blue for object references, for example. You can only connect pins of matching types, which stops many mistakes before they happen.

A quick tour of the Blueprint Editor

Open any Blueprint Class by double-clicking it in the Content Drawer. You will see five areas:

• Toolbar: Compile, Save, Class Settings and Class Defaults. Compile turns your nodes into something the game can run.
• Components panel (top left): the parts of the actor, such as meshes, collision boxes and lights.
• My Blueprint panel (bottom left): your graphs, functions, variables and event dispatchers.
• Graph area (middle): the Viewport tab shows the actor, and the Event Graph tab is where you place nodes.
• Details panel (right): settings for whatever you selected.

To add a node, right-click in the Event Graph and type its name. Drag from a pin and release to see only the nodes that fit that pin. This "context sensitive" search is the fastest way to learn what is possible.

Events: when things happen

Nothing runs until an event fires. Events are the red nodes that start a chain. The ones you will use most:

Variables: what your game remembers

A variable is a named box that stores a value, like a player's health. Create one in My Blueprint with the + next to Variables, pick a type, then click Compile to set its default value.

Drag a variable into the graph while holding Ctrl to get its value, or Alt to set it. Click the eye icon next to a variable to make it Instance Editable. Then every copy you place in a level can have its own value, set in the Details panel.

Branches, functions and the order of nodes

• Branch is an "if": it checks a Boolean and follows the True or False wire.
• Sequence runs several chains one after another from a single event.
• Functions are groups of nodes you can reuse. Select nodes, right-click and choose Collapse to Function to turn messy graphs into tidy, named steps.
• Delay waits a set time. Delays and Timelines cannot go inside functions, so put them in the Event Graph.

Build a door that opens with a Timeline

Use a project made from the Third Person template with Starter Content, like the one from our Unreal Engine 5 beginner's guide. A Timeline is a node that plays a small animation curve over time, which makes the door swing smoothly instead of snapping open.

1. Create the Blueprint. In the Content Drawer, right-click and choose Blueprint Class, then pick Actor as the parent. Name it BP_Door and open it.
2. Add the parts. In Components, click Add, choose Static Mesh and name it Frame. In Details, set its Static Mesh to SM_DoorFrame. With Frame selected, add a second Static Mesh named Door with SM_Door, so it is attached to Frame. Move the door with the W tool until it fits the frame.
3. Add a trigger. Add a Box Collision named Trigger and scale it so it reaches about two meters out on both sides of the door.
4. Add the events. Select Trigger. In Details, under Events, click + next to On Component Begin Overlap and On Component End Overlap.
5. Make the Timeline. Right-click the graph, choose Add Timeline and name it DoorTimeline. Double-click it to open it. Use the Track button to add a Float Track, name the track Alpha, and set Length to 1 second. Hold Shift and click on the track's graph twice to add two keys. Select each key and type its numbers: time 0 with value 0, and time 1 with value 1.
6. Wire it up as below, then compile, save and drag the door into your level.

On Component Begin Overlap (Trigger) -> DoorTimeline: Play
On Component End Overlap (Trigger)   -> DoorTimeline: Reverse

DoorTimeline: Update
  -> Set Relative Rotation (Target: Door)
       New Rotation = Lerp (Rotator)
         A     = 0, 0, 0
         B     = 0, 0, 90   // Z is yaw: 90 degrees open
         Alpha = DoorTimeline Alpha

Lerp means "blend between A and B". When Alpha is 0 the door is shut, at 0.5 it is half open, and at 1 it is fully open. Reverse plays the curve backwards, so the door closes from wherever it is.

Build a key pickup and lock the door

Now the door should stay shut until the player finds a key. The player needs to remember whether they have it.

1. Add the memory. Open BP_ThirdPersonCharacter, add a Boolean variable called HasKey, leave it unticked (false), then compile and save.
2. Make the key. Create another Blueprint Class with the parent Actor and name it BP_Key. Add a Static Mesh such as Shape_Torus from Starter Content, scale it down, and set its Collision Presets to OverlapAllDynamic with Generate Overlap Events ticked. A Rotating Movement component makes it spin.
3. Give it logic. If you built the coin in our beginner's guide, this is the same pattern with a Boolean instead of a number.

// BP_Key, Event Graph
Event ActorBeginOverlap (Other Actor)
  -> Cast To BP_ThirdPersonCharacter (Object = Other Actor)
     -> Set HasKey = true
     -> Destroy Actor (Self)

// BP_Door: replace the old Begin Overlap chain
On Component Begin Overlap (Other Actor)
  -> Cast To BP_ThirdPersonCharacter
     -> Branch (Condition = HasKey)
        True:  DoorTimeline: Play
        False: Print String "Locked. Find the key!"

Place the key somewhere in the level, play, and walk to the door without it. You get the locked message. Fetch the key and the door swings open. You just built a real game mechanic.

How Blueprints talk to each other

Most bugs in bigger projects come from Blueprints that cannot reach each other. Epic's documentation lists several ways to communicate between Blueprints. These three cover almost everything a beginner needs.

1. Casting: "are you the type I think you are?"

You already used it. A cast is quick and clear when one Blueprint needs another specific Blueprint's variables. The downside: the caster must know about that exact type, so heavy use ties your Blueprints tightly together.

2. Interfaces: press E to interact with anything

An interface lets the player say "interact" to any actor without knowing what it is. Doors open, chests give loot, and actors without the interface simply ignore the message.

1. Right-click in the Content Drawer, choose Blueprint > Blueprint Interface and name it BPI_Interact. Rename its function to Interact, add an input called Caller of type Actor, and compile.
2. In BP_Door, open Class Settings. Under Interfaces, add BPI_Interact and compile. Right-click the graph and add Event Interact. Connect it to your HasKey check, using Caller as the Object to cast.
3. Create an Input Action asset (right-click, Input > Input Action) named IA_Interact. An Input Action is a named player action; an Input Mapping Context links actions to keys. Open the template's mapping context in the Input folder (usually IMC_Default), click + next to Mappings, choose IA_Interact and set its key to E.
4. In BP_ThirdPersonCharacter, right-click, search for IA_Interact and add its event, then build the chain below.

EnhancedInputAction IA_Interact (Started)
  -> Get Overlapping Actors (Target = Self)
  -> For Each Loop
     -> Interact (Message)
          Target = Array Element
          Caller = Self

Now pressing E near the door runs its HasKey check. Want the door to open only when the player presses E? Delete the old Begin Overlap chain in BP_Door. Keep End Overlap, so the door still closes when you walk away.

3. Event Dispatchers: announce it, let others react

A dispatcher is a broadcast. The key does not need to know who cares; listeners sign up in advance. In BP_Key, click + next to Event Dispatchers and name it OnPickedUp. Drag it into the graph, choose Call, and place it just before Destroy Actor. In any listener, such as a lamp, add an Instance Editable variable that references BP_Key. Then, on BeginPlay, use Bind Event to OnPickedUp with a Custom Event that turns the lamp green. Pick which key to watch in the lamp's Details panel.

How to debug Blueprints

• Print String shows a message on screen. Use it to check that an event fires at all.
• Breakpoints: select a node and press F9. The game pauses when it reaches that node, and you can hover over pins to see their values.
• Watch it live: while playing, pick the actor in the debug dropdown at the top of the Blueprint Editor. The wires light up as nodes run.
• "Accessed None" errors mean a reference variable was empty when a node used it. Check it with an Is Valid node, or make sure you set it in the Details panel.
• Back up before big changes. Copy your project folder or use Git, a tool that keeps every version of your files, so a broken Blueprint is never a disaster.

Stuck on a graph? An AI assistant can explain nodes and suggest fixes if you describe them well. Our guide on using AI with Unreal Engine shows prompts that work. When your logic is solid, you can even make it work online with the steps in how to make a multiplayer game in Unreal Engine. Want to see what others built? Browse indie games made with Unreal Engine.

Epic's Blueprints documentation is the best reference once you know the basics.