The May sale is here! Save 70% on select products now through May 23.


RecourseDesign - Code Plugins - Dec 15, 2022

rdInst is an optimized C++ plugin that takes care of all your Instanced Static Meshes, Spawned Actors, Child Components, Actor and Component Pooling, Populating, Randomization and Selective Hiding/Showing of these objects.

  • Supported Platforms
  • Supported Engine Versions
    4.27, 5.0 - 5.4
  • Download Type
    Engine Plugin
    This product contains a code plugin, complete with pre-built binaries and all its source code that integrates with Unreal Engine, which can be installed to an engine version of your choice then enabled on a per-project basis.

Latest Version: 1.36 - 15th March 2024


Discord Channel: Here.

Note: rdInst is compatible back to UE4.27 - these built previous versions are available upon request.

Tested on Windows, Linux and Android - should be compatible with Mac and IOS, Playstation and XBox.

The plugin can be used in two ways:

  • As an Editor plugin, providing optimized editing and fast randomization, baking out the results into fast blueprint only actors using either just static meshes or utilizing any method of instancing – or even baked into static meshes (great for Nanite). rdBPtools is completely compatible with rdInst and uses its optimizations when you use its Base Blueprints.
  • As a runtime plugin, packaged along with your project. Providing it’s instancing and spawning routines, and its optimizations for use in real-time – such as randomizing a room to a specific seed before moving it into place. In fact, it is this part that provides the best optimization. You can have many objects in your rooms, each with their own random settings – using rdInst, you don’t even see a drop in framerate when randomizing. Blueprint routines to randomize are somewhat slower – especially when actors rely on other actors to be visible.

rdInst has tools for:

  • Fast and easy access to raw, global ISM or HISM generators from any actor
  • Managed ISMs or HISMs from any actor based on the rdActor
  • Actor Proxies for automatic switching to Full Actors from Instances
  • Powerful Spawn system with large-world compatible proximity spawning
  • Fast Instance to Actor switching and visa-versa
  • Fast Instance Transforming
  • Randomization of transform, visibility, selection of 1 from list etc
  • Themes to control what is visible, and how the randomization is applied
  • A fast, scalable runtime Landscape Population system, optional splatmaps, slope placement fixing, material detection and much more.
  • Actor and Component Pooling
  • Distributed transactions (spread out spawning over multiple frames)
  • Utilities for various system things

Just use the included rdActor as your base actor, or directly call library functions from the rdInst Subsystem.

Instances are managed according to their owning actor, during Editing this allows fast editing of large amounts of meshes – during runtime this allows fast Showing/Hiding of actors and even sub-folders of meshes for each actor.

Non-managed functions are available too – these give raw access to the InstancedStaticMesh and HeirachialInstancedStaticMesh Components used to create the instances.

It’s as simple as calling the “rdAddInstance” node in your Blueprints, specifying the Static Mesh and a Transform. Removing them is as simple as using the “rdRemoveInstances” – it only removes instances used by your current blueprint.

Even with the Management and Randomization system built in, you’re able to get the same performance as the Foliage Tool - in fact quite a bit faster when you're using World Partition with foliage spread over many tiles.

When Adding Instances at run-time, rdInst can be used to distribute the additions over multiple frames to keep the frame rate smooth - all handled behind the scenes.

Technical Details


  • Very Easy to create Instances of Static Meshes
  • Fast Baked/Unbaked Spawning system for Instances, Actors and Niagara (proximity spawning included)
  • Proxies - swap to actors at: Short Proximity, Long-Distance Proximity or Destruction based
  • Runtime baking of PCG and Foliage volumes for proxy support
  • Fast Population system for landscapes built in, control each scalability level
  • Fast Actor and Component Pooling with Events
  • Fast Spline Manipulation and Population in Editor and at runtime
  • All Instances are managed, and looked after behind the scenes
  • Access to the actual Instance generators for raw power
  • Access the rdInst Subsystem from any actor
  • Distributed Spawning
  • Have Hierarchies of Actors/Instances, show and hide whenever, Editor or at Runtime
  • Assimilate child instances into their parents.
  • Apply Randomization of Transform and Visibility with a sophisticated Randomization system
  • Use “Themes”, control the sets of visible Actors/Instances by a Theme
  • Convert any Instance to a StaticMesh, ChildComponent or a Level Actor at Runtime
  • Fast Instance Transformations
  • Speeds up rendering while in the Editor – smoother editing large amounts of objects

Code Modules:

  •  rdInst (Runtime)

Number of Blueprints: 2

Number of C++ Classes: 7, 1 Subsystem

Network Replicated: N/A

Supported Development Platforms: Win64,Linux (should work with all platforms with runtime code)

Supported Target Build Platforms: Win64,Linux,Android (should work with all platforms with runtime code)


Example Project: N/A

Important/Additional Notes: