Houdini Solaris and USD Workflow: 7 Steps to Build Layered Scenes

Houdini’s Solaris tools provide a workspace for building and editing scenes that use USD (Universal Scene Description), and rendering them with Karma. In the approach described in SideFX’s Houdini 22.0 documentation, a scene is assembled from different content layers rather than stored as one fixed file. This guide covers the basic steps for using this structure clearly and effectively in architectural visualization, interior design, and team-based production.

First, understand the core concepts

In USD, the basic units of a scene are elements called prims. A model, light, or material can be a prim; prims can have properties and relationships with other prims. When interconnected USD layers are combined, the resulting scene graph is called a stage. So a “stage file” is not a separate file type; it is the result of combining loaded layers in a particular context.

Solaris is the general name for Houdini’s tools for building scenes with USD and developing their look. In this environment, LOP networks consist of nodes that operate on a USD scene. The documentation says LOPs can be thought of as similar to SOP networks, which work with geometry; the difference is that LOPs take a USD scene as input and produce a new scene.

Build a USD scene in seven steps

1. Identify the scene components. In an architectural project, the building, furniture, decor, lighting setup, or camera settings can each be separate content components. The documentation explains that layers can represent scene elements such as a prop, character, lighting setup, or default settings. The goal is not to increase the number of files, but to control the scope of changes.

2. Define each layer’s role. Decide what each layer represents: for example, one layer might hold model content and another the lighting setup. That way, a team member can update the lighting without having to modify the model layer. USD’s layered structure lets changes be kept separate without directly affecting other users’ content.

3. Bring existing content into the scene. The Houdini documentation describes Sublayer LOP for loading a USD layer into the layer stack of the current stage, and Reference LOP for adding content from another file to a layer. Using references can let you reuse the same asset at different points in a scene while keeping its source content external.

4. Keep edits separate. Instead of modifying an existing asset directly, create an edit in a new layer on top of it. In USD, a property value in a stronger layer can override the value for the same property in a weaker layer. This setup makes it easier to preserve scene edits when a new version of an asset arrives, but you still need to track which information each layer overrides.

5. Develop the stage through the LOP network. Nodes in a LOP network modify the incoming USD scene and produce a new stage as output. Breaking operations into logical stages makes it easier to track where models, lights, or other content enter the scene. Giving each part of the network a clear purpose, rather than combining many operations in one node, helps teams follow the workflow.

6. Inspect the combined result. SideFX’s documentation describes how to view a LOP node’s output as USD text: right-click the node and choose LOP Actions › Inspect Flattened Stage. This is useful for checking the combined contents of the stage and the results contributed by each layer. Treat the text view as a tool for inspection and debugging, not as your everyday editing method.

7. Choose a file format for the task. The documentation states that the .usda extension indicates a readable text format, while .usdc indicates a binary format. .usd can be either text or binary. So don’t assume the file’s internal representation based on the .usd extension alone.

How this affects architectural visualization workflows

A layered structure is particularly useful for teams where multiple people work on the same scene across modeling, lighting, and look development. Bringing an updated asset into scenes that use it as a reference makes it possible to reuse the update and keep scene edits in separate layers. In Solaris, LOPs let you build these operations step by step on a USD scene.

However, USD is a broad framework, and SideFX also notes that learning its core concepts makes working with LOPs easier. At the outset, you’ll need to keep track of where layers are defined, which layer writes each value, and which files references point to. The documentation does not provide hardware requirements, specific hardware recommendations for performance, or licensing costs; check these separately based on your project and setup.

Common mistakes

• Assuming the .usd extension always indicates a binary format. The documentation says this extension can contain text or binary data.

• Writing all changes into the source asset. Editing in a separate layer helps preserve changes made on top of an updated asset.

• Treating a stage and a single layer as the same thing. A stage is the result of combining layers; a USD file can also be used as a layer in another context.

• Using Inline USD LOP as the normal workflow. SideFX says that adding text-based USD with this node can be useful for debugging, but is not the usual way of working.

These steps are based on the Solaris and USD concepts described in the Houdini 22.0 documentation. Where no menu path is specified, focus on understanding the purpose of the relevant LOP and its effect on the scene rather than assuming a particular interface step.