Interchange USD import in UE 5.6 – Unsupported Schemas & Incomplete Blueprint conversion block production adoption

After testing the new Interchange pipeline for USD in UE 5.6 against the legacy workflow, I’ve run into several blockers that currently prevent us from adopting it in production.

  • Unsupported schemas: Any prim using the PointInstancer schema is skipped. The editor logs the warning: “Prim ‘/Root/cubeInstances/instancer_grp’ has schema ‘PointInstancer’, which is not yet supported via USD Interchange.”
  • Blueprint conversion issues: When we enable CREATE_PACKED_ACTOR, the conversion doesn’t fail if unsupported components are present, and-more critically-the generated Blueprint flattens the original USD hierarchy. Preserving this hierarchy is essential, so the loss is a major blocker.
  • Actor spawning limitations: Interchange lacks this UI option; the only workaround is to set scene_hierarchy_type = CREATE_LEVEL_ACTORS in code. While functional, it forces artists to rely on scripts.
  • Root-actor naming bug: Actors spawned through the pipeline are labelled simply “/”, rather than inheriting the prim or asset name. We have to rename them manually after every import.
  • No asset list returned: Unlike the legacy AssetImportTask.imported_object_paths, Interchange provides no list of imported assets, forcing an expensive Content Browser scan for post-processing.

Some of these pain points-such as the naming bug and the missing asset list-can be patched with additional Python, and we can script actor spawning as well. However, the two issues below are true blockers:

  1. Blueprint conversion must keep the original hierarchy.
  2. PointInstancer (and other USD schemas) need native support-especially since the legacy workflow already handles them.

Is there an ETA for addressing these limitations in Interchange? Alternatively, is there a recommended way to inject custom code that translates unsupported schemas and rebuilds actor hierarchies until official support lands? Any roadmap details would help us decide when we can safely migrate.

I’ve put some steps to reproduce when I was creating the ticket but I can’t see it here so, just to make sure this question does have it, I will add it again:

Interchange USD Import — Test Steps

  1. Prepare the USD file
  • Add one complex Static Mesh whose hierarchy is at least two levels deep. This recreates the bug where the Blueprint conversion drops the hierarchy.
  • Add one PointInstancer so you can confirm that this schema is still unsupported.
  1. Editor workflow test
    1. Enable the Interchange USD importer.
  2. Import the USD in the Editor.
    1. Expected outcome:
  • The imported assets are not spawned in the level—you have to place them manually.
  • The PointInstancer is skipped, confirming lack of support.
  1. Python workflow test
  • Import the same USD through Python. I can’t share our full script, but the snippets below highlight the areas where the issues occur:

`def import_usd_prim_with_interchange(usd_filepath: str, asset_name: str, dest_path: str) → bool:

Prep subsystems

eas = unreal.get_editor_subsystem(unreal.EditorAssetSubsystem)
im = unreal.InterchangeManager.get_interchange_manager_scripted()

assets_pipe is basically a duplication of: “/Interchange/Pipelines/DefaultAssetsPipeline”

level_pipe is basically a duplication of: “/Interchange/Pipelines/DefaultSceneLevelPipeline”

Properties to play and try to get the imported asset with the correct naming

assets_pipe.asset_name = asset_name
assets_pipe.use_source_name_for_asset = False

Properties to play to:

1. Get the imported assets instanciated in the level and

2. Create and spawn the blueprint actor with CREATE_PACKED_ACTOR

level_pipe.scene_hierarchy_type = unreal.InterchangeSceneHierarchyType.CREATE_LEVEL_ACTORS

level_pipe.scene_hierarchy_type = unreal.InterchangeSceneHierarchyType.CREATE_PACKED_ACTOR

level_pipe.reimport_property_strategy = unreal.ReimportStrategyFlags.APPLY_PIPELINE_PROPERTIES

Run import_scene or import_asset, I don’t know if either of them will change

anything on this USD import workflow. Also, as I didn’t paste the full code,

you can guess that I am duplicating the original/default pipelines and then

overwriting them with “import_params.override_pipelines”

source_data = im.create_source_data(usd_filepath)
import_params = unreal.ImportAssetParameters()
import_params.set_editor_property(“is_automated”, True)
import_params.set_editor_property(“replace_existing”, True)
import_params.set_editor_property(“destination_name”, asset_name)
import_params.override_pipelines = [
unreal.SoftObjectPath(f"{assets_dest}.{assets_name}“),
unreal.SoftObjectPath(f”{level_dest}.{level_name}")
]
success = im.import_scene(dest_path, source_data, import_params)

success = im.import_asset(dest_path, source_data, import_params)

Rename Imported Actor. I’m having to do this as the assets are being imported into the level

with the root actor being named ‘/’

actor_name = “/”
for actor in unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_all_level_actors():
if actor.get_actor_label() == actor_name:
log_warning(f"[Interchange] Root Actor Found, name changed from ‘/’ to {actor_name}")
actor.set_actor_label(asset_name)`

Hi Arthur,

Please note that Interchange USD is a work in progress and is still experimental and we’re continuously working to improve it for future releases. You’ll have noticed that to do scene import with it, you have to enable it through a cvar. With that in mind, here are the responses to your concerns:

  • We are currently working on adding support for PointInstancers to Interchange USD. This will be released in UE 5.7. What other schemas are you looking for besides PointInstancer?
  • Packed actors support static meshes only. You should use level instance actor instead if you have components other than static meshes. This should preserve the hierarchy as well. Note that Interchange doesn’t support importing to Blueprint and level instance can be used as a replacement.
  • The Scene Hierarchy Type option is already in the UI. To see it, you must select “Import Into Level…” in the File menu. After that, you must select the Default Scene Level Pipeline (as shown below) to see its options.[Image Removed]
  • We are aware of the naming bug for the root actor. This is planned to be fixed in the next release.
  • The function import_asset already returns the list of imported objects; in your sample code, try to print out success (from the call to im.import_asset) and you’ll see that it will print out the list of imported objects. With import_scene, it’s still possible to get the list of imported objects but you need to register a callback on the ImportAssetParameters’ on_scene_import_done.

`def on_import_complete(objs):
print(objs)

delegate = unreal.OnImportDoneDynamic()
delegate.bind_callable(on_import_complete)

.
.
.

import_params.set_editor_property(“on_scene_import_done”, delegate)`Finally, we’re also working on a way for developers to extend the functionality of the Interchange USD translator to support currently unsupported or custom schemas.

Best regards,

Anousack