MetaSounds in UE5: How It Differs from Sound Cue and How to Change Sound from Outside

Look into audio in UE5 and you'll find two systems: Sound Cue and MetaSounds. Both are assets for playing sound, and both are built by wiring nodes, so they look similar. That's exactly where people stall: which one do I use for something new, and what's actually different?

The difference is their role. Sound Cue is a blueprint for picking and playing prepared audio; MetaSounds is a system for building and processing sound itself. The biggest distinction is that MetaSounds lets you change a sound from outside while it's playing. This article covers the difference from Sound Cue, creating a MetaSound Source, the basic nodes, and passing Inputs in at runtime to change a sound.

What You'll Learn

• Sound Cue picks and plays; MetaSounds builds and processes
• Creating a MetaSound Source, plus the Wave Player and Random basics
• Telling the two wire types apart: trigger and audio
• The biggest strength, changing sound during playback by passing Inputs from outside
• Hands-on: driving footstep pitch from movement speed

---

Versus Sound Cue: Picking or Building

The short answer up front: these two aren't competitors, they have different roles.

Sound Cue is a blueprint for taking existing audio (Sound Waves) and picking, mixing, and jittering it. It never touches the source material itself. The Sound Wave and Sound Cue article covers it in detail.

MetaSounds goes a step further and builds and processes sound. You wire nodes much like Sound Cue, but what you can wire is different.

	Sound Cue	MetaSounds
Concept	Pick source audio and play it	Build and process sound
Strengths	Random selection, pitch and volume jitter	All of that plus DSP (filters, synthesis)
Changing during playback	Generally not possible	Changeable from outside via Inputs
Status	Still active	Epic's development focus

The biggest difference is the second-to-last row, changing during playback. Sound Cue locks in how a sound plays at authoring time, while MetaSounds lets you push values in from Blueprint while the sound is playing. Pitch and volume, of course, but also filter amounts and playback intervals, all live.

As for which to use, for anything new MetaSounds is fine. Sound Cue hasn't gone away, and the concepts (pick a source, modulate it, output it) are shared, so understanding one makes the other readable.

---

Creating a MetaSound Source and Patch

Right-click in the Content Browser and choose Sounds > MetaSound Source. Name it and double-click to open the dedicated editor.

The same menu has MetaSound Patch, which serves a different purpose.

Asset	Playable?	Purpose
MetaSound Source	Yes	The actual sound you plug into Blueprint's Sound pin
MetaSound Patch	No	A reusable building block (subgraph) shared across Sources

Start with MetaSound Source. Patches show up once you're at the "bundle up processing I reuse constantly" stage, so you can ignore them for now.

Open the editor and you'll find On Play (input), On Finished (output), and an audio output pin already placed.

• On Play: A trigger that fires the moment this sound starts playing. Your processing starts here
• On Finished: A trigger that tells the engine playback is over. For one-shots, wire here when you're done playing
• Out (Mono / Left, Right): The exit for the actual audio signal that reaches the player's ears

Note: MetaSounds ships as a plugin, but it's enabled by default in UE5's standard templates. If you can't find the nodes, check that MetaSound is enabled under Edit > Plugins.

The Basic Nodes: Wave Player and Random

There are two nodes to learn first. Together they give you "play a source" and "pick randomly from several."

Wave Player plays a Sound Wave (a .wav asset). Its main pins are as follows.

Pin	Kind	Contents
Play	Trigger (input)	Starts playback when fired
Wave Asset	Data (input)	The Sound Wave to play
Pitch Shift	Data (input)	Shifts pitch in semitones. Works during playback
On Finished	Trigger (output)	Fires when playback completes
Out	Audio (output)	The actual audio signal

Random Get is a node that pulls one element at random from an array. Every time its Next trigger fires, it picks an element from the connected array. Set No Repeats to avoid picking the same element twice in a row.

Put three to five footstep sounds in an array, feed it to Random Get, and wire that output into Wave Player's Wave Asset. That's the foundation for "a different footstep every time," and it's the same idea as Sound Cue's Random node.

Triggers and Audio: Two Kinds of Wire

The first thing that confuses people in MetaSounds is that wires come in types. When a connection refuses to snap, it's almost always a type mismatch.

Wire	Meaning	Examples
Trigger	A "do it now" cue. Fires for an instant	On Play, Play, On Finished
Audio	The continuous signal that reaches the ear	Wave Player's Out
Data	Setting values. Numbers and booleans	Float, Int, Bool, Wave Asset

Telling them apart is simple: only pins of the same kind connect. Trigger to trigger, audio to audio, Float value to Float input. When a wire won't draw, check whether the source and destination types match.

Triggers in particular are the heart of MetaSounds. Actions like "pick the next random element" or "play the Wave Player" all happen the instant a trigger fires. Keeping that separate in your head from the continuously flowing audio signal avoids a lot of confusion.

---

Changing Sound from Outside with Inputs

This is the main event for MetaSounds. Create an Input in the graph and Blueprint can push a value into it by name. And it can do so during playback.

There are three steps.

1. In the MetaSound editor's "Inputs" panel on the left, add an Input such as SpeedRatio (Float)
2. Wire that Input wherever you want it in the graph (for example Wave Player's Pitch Shift)
3. From Blueprint, send Set Float Parameter to that sound's Audio Component

For that third node, In Name takes the exact same string as the graph's Input name (SpeedRatio in this example), and In Value takes the value you want to send. The value only arrives when the strings match, so match the case too.

And here's the trap beginners hit first. To send Set Float Parameter, you need a reference to that sound's Audio Component. But there are two families of playback nodes, and only one of them returns a reference.

How You Play It	Return Value	Can You Send Parameters?
Play Sound 2D / at Location	None (fire and forget)	No
Spawn Sound 2D / Attached	Audio Component	Yes

So if you want to change a sound later, you have to play it with a Spawn Sound node. Play Sound leaves you with no reference and nowhere to send Set Float Parameter. When "I added an Input to my MetaSound but nothing changes," suspect this first.

Note: You can send triggers from outside too, not just values. Add a trigger-type Input to the graph and fire it with Set Trigger Parameter (the node that executes a trigger input inside a MetaSound), and you can build things like "one continuously running sound that you beat from outside." Starting with Float Inputs is the easier path.

---

Hands-On: Driving Footstep Pitch from Movement Speed

Running in an action game, sneaking in a horror game, crossing the overworld in an RPG. Making footsteps bounce slightly higher the faster you move conveys speed from the same source audio. Here we'll build a MetaSound that takes movement speed as an Input and shifts footstep pitch on the spot.

What It Looks Like Running

Walking gives you a low, settled footstep; breaking into a run raises it a step; and every footfall still sounds slightly different from the last.

Reproduction Setup

Create a new project from the Third Person template and prepare the following.

Type	Name	Contents
Sound Wave	SW_Footstep_01 – 03	Footstep source audio (three variations)
MetaSound Source	MS_Footstep	What we're about to build
Character	BP_ThirdPersonCharacter	Comes with the template

Add one Input to the MS_Footstep graph.

Input Name	Type	Default	Purpose
SpeedRatio	Float	0.0	0 = walking, 1 = full sprint

The MetaSound Graph

Build the inside of MS_Footstep like this.

On Play (trigger)
  ├─→ Random Get (In Array = [SW_Footstep_01..03], Next = On Play)
  │       └─ Value ─→ Wave Player's Wave Asset
  ├─→ Random Float (Min = -0.5, Max = 0.5, Next = On Play) … per-step jitter
  │       └─ Value ─┐
  │                 Add (Float)
  SpeedRatio ×2.0 ──┘   └─→ Wave Player's Pitch Shift (semitones)
  └─→ Wave Player's Play

Wave Player's On Finished ─→ the graph's On Finished
Wave Player's Out ─────────→ the graph's Out

Pitch is the sum of two things. SpeedRatio × 2.0 gives you "higher when faster" (0 semitones walking to +2 semitones sprinting), and adding Random Float's ±0.5 semitones gives you per-step jitter. Wiring Wave Player's On Finished to the graph's On Finished makes this a one-shot that ends cleanly once a single step has played.

Blueprint Side: Spawn and Send the Value

Footsteps are best triggered the moment the foot lands. Add an Anim Notify to the walk and run animations and build the following from that notify (adding notifies works the same way as in the Sound Cue article).

AnimNotify (foot lands)
  → Get Velocity → Vector Length → ÷ MaxWalkSpeed (e.g. 500) → Clamp(0.0, 1.0)  … SpeedRatio
  → Spawn Sound Attached
        Sound          = MS_Footstep
        Attach to Component = Mesh (a foot socket works too)
        (return) Return Value = Audio Component
  → Set Float Parameter (Target = the Audio Component above)
        In Name  = "SpeedRatio"
        In Value = the SpeedRatio computed above

The key is sending Set Float Parameter to Spawn Sound Attached's return value. Use a Play Sound node instead and there's no return value, so there's nowhere to send the value. The "SpeedRatio" in In Name must match the MetaSound Input name exactly.

Verify It

Hit Play, walk around, then break into a run.

• While walking → A settled, lower footstep. Pitch Shift stays near 0 semitones
• While running → A step higher. SpeedRatio approaches 1 and Pitch Shift rises toward +2 semitones
• At any speed → Each step carries ±0.5 semitones of jitter, so you never hear the exact same sound twice

If something's off, here's how to narrow it down.

• No sound at all → Spawn Sound Attached's Sound is empty, the notify isn't firing, or MS_Footstep's Out isn't connected
• Speed doesn't change anything → Set Float Parameter's In Name doesn't match the graph Input name SpeedRatio (check spelling and case)
• Pitch jumps too much → The SpeedRatio × 2.0 coefficient is too large. Drop it to ×1.0 and confirm
• Same sound every time → The Random Get array only has one element, or Next isn't connected
• Built with Play Sound and can't change it → There's no return value, so you can't get an Audio Component. Switch to a Spawn Sound node

Two things to take away.

• Changing a sound during playback requires an Audio Component: Play Sound nodes are fire-and-forget and return no reference. Use Spawn Sound and send Set Float Parameter to the returned Audio Component. That's the basic shape of dynamic audio. Fitting the resulting sound into your space continues in the attenuation and Submix article
• Inputs are addressed by name: A value only arrives when the graph's Input name and Blueprint's In Name string match. That's the decisive difference between Sound Cue, which locks playback in, and MetaSounds, which you can drive from outside

---

Bonus: Good to Know for Later

The next step is making the music react. The Input mechanism for pushing values in isn't limited to sound effects — it's how you build music that changes with the situation. Run several Wave Players at once and move only their volume, and the soundtrack thickens without ever breaking (→ Interactive Music with MetaSounds).

• Start with "pick a source and jitter it": MetaSounds goes as deep as filters and waveform synthesis, but you don't need all of it up front. Wave Player + Random Get + Input is enough for genuinely useful SFX
• You can audition inside the editor: The play button in the MetaSound editor toolbar previews the sound right there. You can also feed temporary Input values in the editor, so you can nail the sound before writing any Blueprint
• Sound Cue isn't "converted," it's rebuilt: Don't expect a magic button that faithfully ports an existing Sound Cue to MetaSound. The concepts carry over, so rebuilding the ones you actually need is the realistic path
• Watch out for pushing volume too high: Whether inside MetaSounds or via Blueprint's Volume Multiplier, going well past 1.0 clips. If it's too quiet, look at the source file's own level or global adjustment via Submix first
• There's a cap on simultaneous sounds: Fire off a mass of footsteps or bullet impacts at once and anything past the limit simply won't play. Setting "at most N of this kind" with Sound Concurrency keeps things stable

Summary

• Sound Cue is a blueprint for picking and playing source audio; MetaSounds is a system for building and processing sound. Different roles, both still current
• Start with a MetaSound Source. The basic nodes are Wave Player and Random Get
• Wires come in three kinds, trigger, audio, and data, and only matching kinds connect
• The main event in MetaSounds is Input. Blueprint pushes values in by name to change a sound during playback
• To send values, play with a Spawn Sound node and grab the Audio Component. Play Sound nodes return no reference

In the game you're building, which numbers change moment to moment: speed, health, distance? Wire one of them into a sound's pitch or timing and MetaSounds starts to click.