Solaris and USD for Houdini Artists: What Changes in Your Render Workflow
Solaris is Houdini's USD-based context for scene building, look development and Karma rendering. Instead of a ROP reading /obj, you build a USD stage with LOPs and render it with husk.
- Solaris: the umbrella name for Houdini's scene building, lookdev and Karma rendering tools; LOPs generate and modify USD
- Layers: each .usd file is a layer; sublayers, references and payloads compose into the stage
- Assets: the Component Builder writes a .usd that points to a payload with geometry and materials
- Rendering: the USD Render ROP writes a temporary USD and launches husk
- Houdini 22: Layout LOP is now Paint Instances, Instancer LOP is now Copy to Points
Moving from /obj and Mantra or Karma ROPs to Solaris changes more than where your nodes live. In Solaris you are not building a Houdini scene that a renderer reads; you are authoring a USD stage, layer by layer, and the renderer reads the stage.
This guide explains the ideas that change your day-to-day work, layers, components, materials and the render path through husk, and what to set up so Solaris scenes render reliably on another machine. Node names follow the Houdini 22 documentation.
Checked against SideFX Houdini 22 documentation for Solaris, USD, the Component Builder, USD Render ROP, husk and Karma XPU, November 2026.
What Solaris actually is
SideFX describes Solaris as the umbrella name for Houdini’s scene building, look development and Karma rendering tools. Its nodes, LOPs, generate and modify USD. The practical change is that every LOP edits a USD stage: what you see in the scene graph tree is the composed USD that will be rendered, not a Houdini-only representation.
Layers, references and payloads
In USD, a single .usd file is a layer, and the composed result is the stage. Layers combine through sublayers, references and payloads. When two layers set the same property, the stronger opinion wins, following the order USD calls LIVRPS. LOPs write into the strongest sublayer.
How to read the figure. Read the stack from top to bottom as strongest to weakest. The orange layer is where your LOP edits go. The blue sublayers are department files such as lighting and layout, the green row is a referenced asset, and the purple payload holds the heavy geometry and materials that can stay unloaded until needed. The arrow shows that all of them compose into one stage, the yellow box, which is what Karma renders. When a change seems to be ignored, a stronger layer is usually overriding it.
Building assets with the Component Builder
The Component Builder is SideFX’s recommended way to package assets for Solaris. It uses Component Geometry, Component Material, Material Library and Component Output nodes, and writes a main .usd file that points to payload.usdc, which in turn holds geo.usdc and mtl.usdc. It supports variants and a thumbnail.
Materials are authored with the Material Library LOP, which turns shader VOP networks into USD material primitives. Its builders include the Karma Material Builder, the USD MaterialX Builder and the VEX Material Builder. If you plan to use Karma XPU, choose MaterialX: SideFX states that XPU supports only USD Preview Surface, MaterialX and Karma VOPs, and will never support traditional VEX shaders.
How a Solaris render runs
Rendering in Solaris goes through husk, the command-line USD renderer. The USD Render ROP writes the stage to a temporary USD file and launches husk on it.
How to read the figure. Follow the arrows from left to right. The LOP network builds the stage, badge 1 is the USD Render ROP that writes it to a temporary USD file, and badge 2 is husk, the separate process that renders it with Karma CPU or XPU and writes the frames. The command box shows the same render run by hand: frame 1, 24 frames, written as numbered EXRs. The last line is the farm-friendly option: with Run Command off, the ROP only writes USD files, which you can render later with husk on another machine.
Settings for reliable, resumable renders
The mockup shows the settings worth checking before you render a Solaris shot on another machine.
How to read the figure. Badge 1 is the component payload, which keeps heavy geometry and materials out of the main file until it is needed. Badge 2 is the material builder: MaterialX keeps the asset renderable on both Karma CPU and XPU. Badges 3 to 5 are on the USD Render ROP: rendering all frames in a single process avoids reloading the stage every frame, Skip Existing Frames lets an interrupted render resume, and turning Run Command off writes USD files only for batch rendering with husk. The bottom-right panel is the hardware reminder: Karma XPU needs NVIDIA driver 570 or later and does not pool GPU memory.
What changed in Houdini 22
- The Layout LOP is now the Paint Instances LOP, and the Instancer LOP is now the Copy to Points LOP, so older tutorials use names you will not find.
- New nodes include the USD Create Component SOP and the Scatter Instances, PointInstancer, Relocate and Plane LOPs. XformCommonAPI is on by default.
- husk gains
--skip-existing-frames,--passand--karma-percent-of-samples. - Karma XPU memory use for subdivided meshes drops by up to half, and MaterialX is updated to 1.39.5.
Use this list when you move a Solaris scene to another machine.
SaaS or IaaS for Solaris and Karma
USD scenes depend on file paths, asset resolvers and versions, which matters when you render somewhere else.
Rendering Solaris scenes off your workstation
A neutral comparison for Houdini artists.
| Your situation | SaaS render farm | IaaS render farm (iRender) |
|---|---|---|
| Your stage references many USD files | All files and paths must be packaged for the farm | Upload the project folder and keep relative paths as at home |
| You need a specific Houdini build | Limited to the versions the farm supports | Install the build you use; the server image is kept |
| You render with husk from the command line | Depends on the farm's submission tools | Run husk yourself, one process or one per GPU |
| Licensing | Usually provided by the farm | You bring your own SideFX licences |
Rendering Solaris scenes on an iRender server
How to read the figure. The top row is the setup: your own PC or Mac connects by remote desktop to a whole bare-metal server with 1, 2, 4 or 8 GPUs, so you open your Houdini project there exactly as at home. The numbered row is the order of a session: register and top up, upload to iRender Drive before the server runs, start and connect, render a test frame and the job, then shut down so billing stops.
- Register an iRender account and top up; the first top-up of $50 or more gets a 100% bonus.
- Upload the project folder, with its USD layers and textures, to iRender Drive before you start the server.
- Start a 1x, 2x, 4x or 8x RTX 4090 or RTX 5090 server and connect by remote desktop.
- Install Houdini once with your own SideFX licence; the server image is kept between sessions.
- Render one test frame with the USD Render ROP or husk, then the sequence with skip-existing-frames on.
- Download the frames and shut the server down so billing stops.
Frequently asked questions
1. What is Solaris in Houdini?
SideFX describes Solaris as the umbrella name for Houdini’s scene building, look development and Karma rendering tools. Its LOP nodes generate and modify USD.
2. What is the difference between a reference and a payload?
Both bring another USD file into the stage. A payload can stay unloaded to save memory, which is why the Component Builder puts heavy geometry and materials in a payload.
3. Why is my edit in Solaris ignored?
Usually a stronger layer sets the same property. USD resolves conflicting opinions in LIVRPS order, and LOPs write into the strongest sublayer.
4. Can Karma XPU render my VEX shaders?
No. SideFX states that Karma XPU will never support traditional VEX-based shaders. Use MaterialX, USD Preview Surface or Karma VOPs.
5. How does the USD Render ROP render?
It writes the stage to a temporary USD file and launches husk. With Run Command off it only writes USD, which you can render later with husk.
6. Can I render Solaris scenes on iRender?
Yes. Install Houdini on the server with your own SideFX licence and render with the USD Render ROP or husk on 1 to 8 GPUs; the server image is kept between sessions.
Run your Houdini scenes on iRender
iRender is an IaaS GPU render farm: you rent a bare-metal server with 4x NVIDIA RTX 5090 (32 GB) GPUs, an AMD Ryzen™ Threadripper™ PRO CPU, 256 GB ECC RAM and a 2 TB NVMe SSD, connect by remote desktop and work on it like your own workstation, with full administrator access. You install Houdini and use your own SideFX license; your server image is saved between sessions, so Houdini, your packages and caches stay installed. For Karma XPU and GPU-accelerated solvers we recommend the 4-GPU servers.
Multi-GPU servers are billed per minute (1-GPU servers have a one-hour minimum), and sessions of 3 hours or more get 10% off. Our 4-GPU servers are liquid-cooled; in our own measurements the GPUs hold 60–70°C under sustained render load. Elite support is available 7 days a week by hotline, live chat, Skype, WhatsApp and email.
This video walks through rendering a Houdini Karma XPU scene on an iRender server in five steps:
New users get a 100% bonus on the first top-up (minimum $50). See the Karma XPU render farm page for server options, or download the iRender GPU app.
If Karma XPU renders are slow on your machine, iRender’s Karma XPU render farm gives you a dedicated remote server where you install Houdini, bring your own license and render on multiple RTX 5090 GPUs (for Karma XPU, 4 GPUs is usually the most efficient setup).


