[UE5] Instancing 101: Batch Repeated Props with ISM and Reduce Rendering Cost

Ruined pillars, roadside fences, rocks on a plain. Adding identical props enriches the scenery while also increasing the cost of treating each one as a separate Actor.

What to try here is instancing . Treating it as "place this same shape at these positions" can keep the visible count while lightening rendering preparation and placement management.

UE uses the Instanced Static Mesh (ISM) component. This article starts from comparing already-placed props batched together, then lines up one pillar and then eight in Blueprint.

What You'll Learn

• The difference between draw call counts and stat unit 's Draw time
• What ISM shares and what varies per placement
• Converting placed Actors and adding more with Add Instance
• Choosing among ISM, HISM, and Foliage, plus caveats for deletion and distance settings

This assumes Windows UE5 and experience with placing Actors and basic Blueprint work. We use no external assets and copy Engine basic shapes for practice. The figures are schematics for the article, and the Blueprint diagrams exist so you can reproduce the connections.

ISM holds one shape and many placements

An ISM instance is one placement using the same mesh. A mesh is the data representing a 3D model's shape, and ISM shares that shape and its materials. Where to put it, which way it faces, and how large it is can each vary.

That bundle of position, rotation, and scale is a Transform . Thinking of ISM as holding "a shared shape" and "individual Transforms" makes it clearer.

With 32 identical pillars, for instance, instead of 32 Actors you attach one ISM component to one Actor holding 32 placements. Sharing the shape still lets you tilt one or shorten another.

Separate Draw time from draw call counts

A draw call is an instruction to the GPU to render. Batching draws that meet the right conditions reduces the burden of handling those instructions. Grouping work like that is called batching .

It is not fixed that 32 pillars mean 32 calls and ISM means exactly one, though. The materials used within the shape, separate passes such as shadows, and LOD (models at different detail levels) all split it. Even the original Actor placement may already have the engine batching draws automatically.

What you want to check	What to look at
CPU-side time preparing draws	stat unit 's Draw (ms)
Changes in draw call counts	Mesh draw calls and similar in stat scenerendering
Whether the game got lighter overall	Frame plus the Game, Draw, and GPU times

Draw is a time, not a count. A large value is a cue to investigate draw preparation, but does not by itself pin the cause on draw calls. Together with the stat command article, look at before and after in the same scene.

Switching to ISM does not automatically reduce the pillar faces or pixels on screen. It can reduce the cost of managing many Actors and Components individually, though. Do not judge the whole effect by draw call counts alone.

Reference: Instanced Static Mesh Component, Merging Actors, Foliage Mode, Add Instance.

Hands-On: batch already-placed props and compare

Rather than mass-generating in Blueprint first, confirm by replacing props already in place with ISM . Keeping the placement makes it harder to confuse "it got lighter because things moved".

Prepare two levels for comparison

Save a walkable Third Person template level for practice and use it.

1. Turn on "Settings → Show Engine Content" in the Content Browser.
2. Select the Sphere under "Engine → BasicShapes" and Ctrl + C . Press Ctrl + V in a practice folder in your own Content and name it SM_InstanceProbe .
3. Open the copy and turn "Nanite Settings → Enable Nanite Support" off. If you changed it, press "Apply Changes" and save.
4. Place one sphere on the floor and duplicate it by dragging with Alt held. Selecting several and duplicating together makes reaching about 32 easy.
5. Arrange them in a few rows somewhere open, without overlapping too much. A small area you can take in at once is enough at first.

Save this as L_Instances_A and create L_Instances_B via "File → Save Current Level As". A is the comparison baseline and B is what we convert. When increasing the count, do so before splitting into two.

Batch only B

Open B and select only the sphere Actors. Do not include the floor, Player Start, or lights.

1. Open "Actor → Merge Actors → Merge Actor Settings" in the top menu.
2. Set the method to Batch , which batches identical meshes into instances.
3. Choose Instanced Static Mesh Component under "Select the type of Instanced Component".
4. Set "Instance Replacement Threshold" to 2 , the condition for how many identical meshes trigger conversion.
5. Turn "Replace Source Actors" on and run "Merge Actors". That replaces B's original spheres with the generated Actor.

Select the generated Actor and confirm the ISM component and instance count in the Details panel. With 32 spheres, 32 placements remain; confirm the visible positions are the same before saving. Depending on the conversion settings, components can be split into several.

Leaving both original and converted spheres would compare double drawing. Confirm in the Outliner that B's original Actors were replaced. To redo it, you can recreate B from A.

Measure from the same viewpoint

Launch A and B in Standalone and view from the same place and direction. Keep the Player Start, quality, resolution, and FPS cap common, and note values after loading settles.

Entering stat unit and stat scenerendering in the launched game's console displays times and draw call counts. How to open the display is covered in the stat command article above.

What to record	A: individual Actors	B: ISM
Visible sphere count and layout	Confirm before the change	Confirm it matches
Frame / Game / Draw / GPU	Record each in ms	Record under the same conditions
Mesh draw calls	Record the displayed count	Watch the change

At around 32, a small time difference is unsurprising. Once you have confirmed the mechanism, try comparisons at 128 and 256. How many milliseconds it drops depends on the model and the execution environment.

• Draw calls dropping and Frame shortening means it is an effective change in this scene.
• Calls dropping without Frame changing means also looking at other GPU work and the FPS cap.
• Calls barely changing means investigating pre-existing automatic instancing or draws outside your target.

If the difference is unclear, return to A once and confirm the same trend appears. Rather than concluding from small fluctuations, confirm in actual gameplay scenes too.

Choosing among ISM, HISM, and Foliage

ISM is not the only way to line up identical shapes. Choose your candidate by "how you place it" and "how much it moves".

Method	The idea	When to try it
ISM	One component holds many placements	The basic first try. Moving placements or pairing with Nanite
HISM	Groups placements into a spatial hierarchy	Thousands of nearly static plants and rocks
Static Mesh Foliage	Painted with a brush, instanced internally	Placing natural objects on terrain quickly

HISM 's hierarchy divides a wide area into small groups to narrow down "which region is visible". It helps with large static placements, but frequently changing placements makes updating the hierarchy costly too.

Current ISM supports per-instance LOD and culling as well. You need not remember "ISM draws everything even far away" or "large counts unconditionally mean HISM". Try ISM first and swap to HISM to compare where it seems to fit.

Foliage also has Actor Foliage . That places Actors and should not be expected to batch draws the way Static Mesh Foliage does. When using it from the Landscape article, confirm which you are placing.

Grow from one pillar to eight in Blueprint

With batching of manual placement understood, next we add from Blueprint. That applies to roadside pillars and props arranged to a room's size.

First, emit just one

Create BP_InstanceRow with Actor as the parent. Add an Instanced Static Mesh via "Components → Add" and name it Posts . Keep DefaultSceneRoot, set Posts' position and rotation to 0, and scale to 1 on each axis.

Specify Cube from Engine's BasicShapes in Posts' "Static Mesh". To copy it for practice, follow the same steps as the first Sphere. Set "Mobility" to Movable and, since we only look at rendering here, "Collision Presets" to NoCollision . Do not add entries to "Instances" manually; leave it empty.

Drag Posts into the Event Graph as a Get and create Add Instance from it. That node adds one placement to the specified ISM component.

1. Connect Event BeginPlay's exec output into Add Instance's exec input.
2. Connect Posts' output into Add Instance's Target .
3. Place Make Transform with Location (0, 0, 50) , Rotation (0, 0, 0) , and Scale (0.5, 0.5, 1) .
4. Connect Make Transform's Return Value into Add Instance's Instance Transform .
5. Leave Add Instance's World Space off .

Make Transform builds a value, so no white exec line goes through it. Target is "which ISM to add to" and Instance Transform is "where, facing which way, at what size".

With World Space off, coordinates are relative to Posts' position and rotation . Moving BP_InstanceRow elsewhere in the level moves the pillars with it. Turn it on to specify from the world origin.

Compile, save, and place one BP_InstanceRow in the level. Keep the Actor's rotation at 0 and scale at 1 on each axis, align its origin with the floor height, and Play. The standard Cube is 100 cm per side, so this Scale makes a 50 cm wide, 100 cm tall pillar. Raising the center to Z=50 puts its base on the floor.

One pillar appearing is success. If none appears, check Posts' Static Mesh, the exec line, whether Scale is 0, and whether you placed the Actor in the level.

Repeat the same connections eight times

Using the current Add Instance and Make Transform, change it as follows.

1. Insert a For Loop between BeginPlay and Add Instance with First Index 0 and Last Index 7 .
2. Connect the For Loop's Loop Body into Add Instance's exec input. Completed can stay unconnected.

At this stage eight pillars stack in the same place. Next we make the position change each iteration. The For Loop and Make Transform in the diagram below are the same nodes you just connected. There is no need to build a second pair.

3. Create an integer Multiply (×) from Index with 200 on the other input.
4. Place Make Vector with the multiplication result into X, 0 into Y, and 50 into Z. Use automatic conversion where integer-to-float conversion is needed.
5. Connect Make Vector's Return Value into the existing Make Transform's Location. Leave the other values as they are.

The "i → f" in the diagram represents the automatic conversion letting an integer be treated as a float.

Index goes 0, 1, 2 … 7, so X becomes 0, 200, 400 … 1400. 0 through 7 is eight iterations . That gives one row of pillars at 200 cm — 2 m — intervals.

Play again, and eight pillars in a row is success. Changing Last Index to 3 gives four, and changing the interval to 300 gives 3 m spacing. That shows you can change the scenery through placement data alone while sharing the shape.

This logic runs once in BeginPlay. Wiring it to Tick would keep adding every frame, so do not move it there as is. To make it a feature that rearranges repeatedly, also decide how to rebuild, such as clearing previous placements with Clear Instances first.

Change and delete using indices

Add Instance's Return Value is the added placement's index . It is the number saying which entry within Posts to operate on, different from an Actor reference.

Node	Role
Add Instance	Adds a placement and returns its index
Update Instance Transform	Changes the specified index's position, rotation, and scale
Remove Instance	Deletes the specified index's placement and returns success
Clear Instances	Clears all placements on that component

To move one pillar, for instance, pass the index from when it was added into Update Instance Transform. Match the coordinate space to what you used when adding, and turn Mark Render State Dirty on when you want a single change reflected in the display.

An index is not an unchanging ID

Once deletion or rebuilding is involved, the same index can refer to a different placement . Some implementations shift subsequent entries down and others move the last placement into the freed index, so do not assume "just decrement the indices after the deleted one".

For building and arranging as we do here, there is no need to store indices long-term. Once you want to record felled trees or harvested rocks, manage an unchanging per-object ID separately from the ISM index. Try changing and deleting one placement first, then move to a design that updates the mapping after deletion.

"Moving it underground instead of deleting" can leave placement data and collision behind. Hiding the display and removing an unused placement are separate.

It can have collision but is not an independent Actor

ISM supports collision too, so you can hit individual pillars. We set NoCollision earlier only to make placements easier to confirm.

Each pillar does not get its own Event Graph or HP variable, though. Material and collision settings are basically shared on the component. If you need per-pillar reactions such as breaking, burning, or talking, design a mechanism where the manager identifies which placement is being acted on.

While learning, building objects with lots of individual behavior as Actors and trying ISM on repeating background is easier to progress with. It is not a limit of "ISM can never have reactions" but a difference in where behavior lives.

How distance culling and Nanite relate

Culling by distance is separate from batching draws

Switching to ISM does not make props disappear at a distance you choose. Distance culling is a separate adjustment saying "do not draw beyond here".

If you did not copy the Cube earlier, make a practice copy now. Turn its Nanite off, assign it to Posts, set these values in the Details panel, and Play. Move the camera away from the row of pillars.

Setting	Practice value	Meaning
Instance Start Cull Distance	1000	The distance where the fade value starts changing, 10 m
Instance End Cull Distance	1500	The distance excluded from rendering, 15 m

Confirm pillars beyond End disappear and come back as you approach. If they pop in and out abruptly, a real game needs them kept much further. When comparing performance before and after, return both distances to 0 first so distance culling does not mix in.

Entering Start alone does not make an ordinary opaque material fade. Smooth fading needs a material reading the PerInstanceFadeAmount fade value and applying it to something such as masking. Confirming the End-based hiding is enough for this exercise.

If nothing disappears, confirm Nanite is off, End is not still 0, and the camera moved far enough. Together with the LOD and culling article, tune both the look and the cost.

Nanite and ISM work together

Nanite is a mechanism drawing detailed models at the range and detail needed. ISM can use Nanite meshes too.

Even with rendering made efficient on the Nanite side, the effect of reducing individual Actors and Components is not necessarily the same. Rather than deciding "Nanite means ISM is unnecessary", look at Frame and Game times and the number of placements you manage.

When using Nanite, treat ISM as the baseline. The traditional-mesh distance culling and fading above may not apply directly, though. Check the coverage for your version and placement method in the Nanite article.

Bonus: good to know up front

Split batching by kind and settings

Different shapes such as pillars and rocks go into separate ISM components. Even the same shape batches differently when materials or settings cannot be shared. To vary color per instance, Per Instance Custom Data passes per-placement numbers into the material.

PCG and Foliage may already be instanced

PCG's Static Mesh Spawner and Static Mesh Foliage are entry points that create these placements. Something that looks like a large quantity is not necessarily individual Actors to begin with. Confirm how things are currently placed before converting.

With many changes, measure the update time too

Changing hundreds of Transforms every frame or spawning and deleting frequently is work in itself. If it is light while static but hitches during play, look at the heavy sections with Unreal Insights.

Start by picking one prop your game uses repeatedly. Keep the same scenery and compare how the placement is held. That small experiment shows what is worth handing over to ISM.

Summary

• Fewer draw calls lower stat unit 's Draw time
• ISM draws "the same mesh with the same material" together in one go
• Position and scale vary per placement while materials are shared
• Deletion shifts indices, so decide how to handle them before using it

The question to ask before using it is "do dozens of the same thing line up here?" If they do, ISM; if each one differs, ordinary Actors are fine.

To place automatically, see the PCG introduction; for other ways to reduce rendering, LOD and culling.