Converting Principled Shader Materials to MaterialX for Karma XPU
Why Principled Shader materials look wrong in Karma XPU, and how to rebuild them:
- XPU does not run VEX: SideFX’s documentation says Karma XPU will never support VEX-based shaders. A Principled Shader either does not work in XPU or is an approximation at best.
- Rebuild on MtlX Standard Surface: inside a Karma MaterialX Builder, the MtlX Standard Surface node is SideFX’s recommended uber-shader and most Principled parameters have a direct Standard Surface input.
- Get the texture signatures right: color maps use a Color signature, normal maps a Vector3 signature through an MtlX Normalmap node, and displacement goes through an MtlX Surface Material or Collect node.
- On iRender: 4x RTX 5090 servers with your own Houdini install, so you can compare Karma CPU and XPU renders of the converted materials on the GPUs that will render the shot.
You switch Karma from CPU to XPU for faster previews and the materials break: metals turn flat, glass loses its look, textures change. The reason is simple. Most legacy Houdini materials are built with the Principled Shader, which is a VEX shader, and Karma XPU does not run VEX.
This guide explains what SideFX supports in Karma XPU, how to rebuild a Principled Shader material on MtlX Standard Surface, how to wire textures, normal maps and displacement, and how to check the result. It follows the SideFX Houdini documentation and the Autodesk Standard Surface specification that MtlX Standard Surface implements.
Why Principled Shader materials break in Karma XPU
SideFX is direct about this: Karma XPU will never support VEX-based shaders, and VEX shaders only work with Karma CPU. The Karma XPU page lists what XPU does support: USD Preview Surface, MaterialX and Karma-specific VOP nodes such as the Karma Hair shader. Everything else, including the Principled Shader, will either not work or be an approximation at best.
That approximation is why a scene does not simply go black. The Material Library LOP tries to create a USD Preview Surface from your material automatically, and SideFX notes this works best with the Principled Shader and MtlX Standard Surface. USD Preview Surface is a much simpler shading model, so effects such as subsurface scattering, coat and sheen, and any VEX patterns in the network, are lost.
Build the new material in a Karma MaterialX Builder
- Create a Material Library LOP and dive inside.
- Create a Karma MaterialX Builder, rename it after the material and dive inside.
- Create an MtlX Standard Surface node and wire it to the output. For Karma XPU, the surface terminal must be MtlX Standard Surface, MtlX Unlit Surface or USD Preview Surface (or Karma Hair and Fur for curves).
SideFX recommends the Karma MaterialX Builder for Karma XPU. Inside it, the Tab menu only shows Karma, Preview Surface and MaterialX-compatible nodes, so you cannot add a VEX node by accident. Use the USD MaterialX Builder instead only if you need a pure MaterialX graph that other renderers can read. Note one difference from the Principled Shader: MtlX Standard Surface does not bind its parameters to geometry attributes automatically, so attributes such as Cd have to be read with nodes like MtlX Geometry Color or a primvar reader.
Map Principled Shader parameters to Standard Surface
MtlX Standard Surface implements Autodesk’s Standard Surface model, which, like the Principled Shader, is a physically based uber-shader. Most settings have a direct input; set them from the old material, then compare renders, because two shading models never match exactly.
| Principled Shader | MtlX Standard Surface input | Notes |
|---|---|---|
| Base Color | base_color (with base = 1) | Base is the weight of the diffuse layer |
| Use Point Color (Cd) | base_color fed by MtlX Geometry Color | Standard Surface does not read Cd by itself |
| Metallic | metalness | 1 for raw metals |
| Roughness | specular_roughness | Compare highlights after conversion |
| Reflectivity / IOR | specular_IOR | Standard Surface uses an index of refraction; 1.5 is a common dielectric value |
| Transmission | transmission, transmission_color | For glass and liquids |
| Subsurface | subsurface, subsurface_color, subsurface_radius | Set the subsurface weight above 0 to enable it |
| Coat | coat, coat_roughness, coat_IOR | Clear coat layer |
| Sheen | sheen, sheen_color, sheen_roughness | Fabric and velvet |
| Emission | emission, emission_color | Emission weight and color |
| Alpha / opacity | opacity | Cut-outs such as leaves |
| Normal map | normal, through MtlX Normalmap | See the texture section below |
Input names from the Autodesk Standard Surface specification and Houdini’s MtlX Standard Surface node.
Wire textures, normal maps and displacement
Texture handling is where most conversions go wrong, because MtlX Image needs to know whether a file holds colors or raw data. That is set by its Signature.
- Color textures: create an MtlX Texcoord with the Signature set to Vector2, then an MtlX Image with the Signature set to Color, and wire the image into base_color (or another color input). This is the order shown in SideFX’s MaterialX quick start.
- Normal maps: set the MtlX Image Signature to Vector3 so no color transform is applied, pass it through an MtlX Normalmap node and wire that into the normal input.
- Displacement: feed a Float height map into an MtlX Displacement node. A Standard Surface node on its own has nowhere to plug displacement in, so use an MtlX Surface Material or a Collect node, which take both the surface and the displacement.
- UDIMs: use the <UDIM> token in the file path.
Limits to keep in mind in Karma XPU
- Karma XPU supports most of MaterialX, but not building a surface from individual MaterialX PBR (BSDF) nodes; use Standard Surface as the terminal.
- Two Standard Surface nodes can be blended with mtlxmix; SideFX’s XPU page documents blending two.
- Karma does not support surface and volume materials on the same prim, and volume materials only work on VDB primitives.
- String inputs are not allowed, even for passing a name through a material’s public interface.
- MaterialX, USD Preview and Karma nodes can be mixed in Karma CPU and XPU, but other renderers usually cannot read such mixed networks.
Check the converted material
- Render the asset with the old Principled material in Karma CPU under a neutral HDRI and save the frame.
- Assign the new MaterialX material and render the same frame in Karma CPU. Compare highlights, roughness and normal detail; this isolates the material change from the engine change.
- Switch the Karma Render Settings engine to XPU and render again. Karma XPU is not a replacement for Karma CPU but a faster engine with a smaller feature set, so differences now point to features XPU does not support; check them against the support list on SideFX’s Karma XPU page.
- Once a material is right, save it as a template or HDA so the next conversions start from the same wiring.
SaaS or IaaS render farm for converting materials to MaterialX?
Both farm models render the same image once the materials are converted, because the networks are saved in your scene or USD files. The difference is where you do the conversion and comparison work, which is interactive: change a node, render, compare, repeat.
| Your situation | SaaS render farm | IaaS render farm (iRender) |
|---|---|---|
| Materials are converted and the shot is approved | A good fit. Upload the project and the farm renders the frames, often across many machines, with no server to manage. | Also works, but you start, use and stop the server yourself. |
| You have a deadline and need to know when rendering starts and ends | Jobs join the farm’s queue, so the start time depends on how busy the farm is; many farms sell higher-priority plans to start sooner | The server runs only your job from the moment it boots, so you control when rendering starts and can time the whole job |
| You are still converting and comparing materials | Each comparison is a job: submit, wait, download and compare. | Switch between Karma CPU and XPU in the Solaris viewport on the server and compare on screen. |
| Your own GPU is slow or the asset does not fit in its memory | Look development at home is slow, so every test round moves to the farm. | Do look development and rendering on RTX 5090 cards with 32 GB each. |
A comparison of how the two farm models work for this task, not a speed test.
A simple rule: if the materials are already converted and approved, a SaaS farm is a good fit for the final frames. If you still need to rebuild and compare materials, or your own GPU struggles with the asset, do the work on an IaaS server and render the shot there too.
A material check on an iRender server
- Upload the project, textures and caches to iRender Drive before you start the server; uploading is free and does not use rental time.
- Start a 1-GPU server for look development, or a 4-GPU server if you will render the shot on it. Install Houdini once and sign in with your own SideFX license; your server image is saved between sessions.
- Rebuild and compare the materials in Karma CPU and Karma XPU in the Solaris viewport.
- Render the shot with husk once the materials are approved. If the deadline is tight, start more servers and give each one a frame range; the total cost stays about the same.
Before you render the sequence on another machine
- Use the same Houdini release; MaterialX node support changes between releases.
- Check that every material on the stage is a Karma MaterialX or USD Preview network, not a leftover Principled Shader.
- Make sure texture paths, including <UDIM> paths, point to files that exist on the render machine.
- Render one frame in Karma XPU and compare it with your approved look-dev frame.
- Time the heaviest frame before you start the full range.
Frequently asked questions
1. Does Karma XPU support the Principled Shader?
No. SideFX’s documentation says Karma XPU will never support VEX-based shaders, and the Principled Shader is a VEX shader. In XPU it either does not work or is an approximation at best, because only USD Preview Surface, MaterialX and Karma-specific nodes are supported.
2. What replaces the Principled Shader in Karma XPU?
Use MtlX Standard Surface inside a Karma MaterialX Builder. It is a physically based uber-shader similar to the Principled Shader, and most Principled parameters, such as base color, metallic, roughness, transmission, subsurface and coat, have a matching Standard Surface input.
3. Why do my normal maps look wrong after converting to MaterialX?
The MtlX Image node is probably using a Color signature, which treats the normal map as a color. Set its Signature to Vector3 and pass it through an MtlX Normalmap node before the normal input of Standard Surface.
4. How do I add displacement to a MtlX Standard Surface material?
Feed a height map into an MtlX Displacement node. Standard Surface has no displacement input, so connect both the Standard Surface and the displacement to an MtlX Surface Material or a Collect node, and use that as the material output.
5. Should I use the Karma MaterialX Builder or the USD MaterialX Builder?
SideFX recommends the Karma MaterialX Builder when you render with Karma, because its Tab menu only shows compatible nodes. Use the USD MaterialX Builder when you need a pure MaterialX graph that other renderers can read.
6. Can I compare Karma CPU and XPU on the machine that renders the shot?
Yes, on an IaaS render farm. On iRender you rent the whole server with your own Houdini install, so you can switch the engine between CPU and XPU in Solaris, compare the converted materials on screen and render the shot on the same GPUs.
Render your Houdini Karma XPU 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 the Karma XPU kernel cache stay installed. For Karma XPU 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.


