Houdini + Karma XPU Pre-Flight Checklist: 10 Checks Before You Render
A Solaris scene that renders on your desk can still break on another machine. Run these checks first:
- Paths: $HIP / $JOB only, collected with Pre-Flight Scene.
- Shaders: MaterialX or USD Preview Surface; other shaders are approximated.
- Driver: NVIDIA 570 or later (575+ on Windows), kernels pre-compiled.
- GPUs: every card shows OptiX and renders a share; memory is not pooled.
- Test: render one frame with husk before the full range.
A Karma XPU scene that renders cleanly on your workstation can still fail on another machine: a texture path points at your own drive, a shader falls back to an approximation, or one GPU quietly drops out and the CPU finishes the frame. This checklist covers the ten things to verify before you send a Houdini Solaris scene to a render farm or a second workstation, with each point taken from SideFX’s own documentation.
Checked against the SideFX Houdini and Karma documentation, November 2026.
The 10-point pre-flight checklist for Houdini and Karma XPU
1. Make every path relative to $HIP or $JOB
SideFX defines $HIP as the folder that contains your .hip file and $JOB as the project folder. Use $JOB for files shared across shots and $HIP for files that belong to one scene. A scene whose references all start with $HIP or $JOB opens correctly on any machine where you copy the project folder; an absolute path such as D:/assets/tex/wall.exr breaks as soon as the drive letter changes.
Source: SideFX, Basics › Project.
2. Collect dependencies with Render › Pre-Flight Scene
Houdini’s Render › Pre-Flight Scene window lists the files the scene depends on, so you can see which ones live outside the project. Move or copy those into $HIP or $JOB before you package the project. The Dependencies window shows the same information per node.
3. Keep USD layers, references and payloads inside the project
In Solaris, every sublayer, reference and payload is another file the render machine has to find. Save them under the project folder and reference them with $HIP-based or relative paths. Our guide to Solaris and USD for Houdini artists explains how these layers fit together.
4. Write simulations and caches to disk inside the project
Karma renders what is on disk, not what is cooked in your session. Write simulation and geometry caches (.bgeo.sc, VDB) to a folder inside $HIP or $JOB, check that the frame range is complete, and upload the cache folder with the scene. See caching simulations to disk and uploading Houdini caches to a render farm.
5. Use shaders Karma XPU supports
SideFX states that Karma XPU is “not a replacement for the Karma CPU engine”: it is a faster engine with a limited feature set that “may have less functionality, and/or generate different output” than Karma CPU. The supported surface shaders are MaterialX (MtlX Standard Surface, MtlX OpenPBR Surface, MtlX Surface Unlit), USD Preview Surface and Karma-specific VOP nodes. Other shaders, such as the Principled Shader, are converted to USD Preview Surface “with varying levels of success.” Our guide to converting Principled Shader materials to MaterialX covers the conversion.
Other XPU limits worth checking before a long render:
- Dome lights support lat-long environment maps only, not sixpack or cube maps.
- A maximum of 4 trace sets per scene, shared between custom and SSS trace sets.
- A maximum of 4 shadow-linking rules or groups per scene.
Source: SideFX, Karma XPU.
6. Check the NVIDIA driver and GPU generation
Karma XPU needs NVIDIA driver 570 or later. SideFX strongly recommends 575 or later on Windows, and 580 or later for Maxwell, Pascal and Volta GPUs. GPUs need Compute Capability 5.0 (Maxwell) or higher; machines without a supported NVIDIA GPU use only the Embree CPU device.
7. Pre-compile the render kernels before the first frame
From Houdini 21, Render › Pre-compile Karma XPU Render Kernels compiles the GPU kernels ahead of time. The first compile after a new Houdini build or a new driver takes a minute or two and is then cached. Only the render kernels are pre-compiled; your own shaders still compile when the scene loads. If GPUs fail to start or the first frame stalls, see fixing multi-GPU initialization and OptiX kernel compilation delays.
Source: SideFX, Karma XPU kernel pre-compilation.
8. Confirm every GPU is rendering
Open the render stats and check the device list. Each GPU appears as OptiX and the CPU as EmbreeCPU, with a status of idle, init, disabled or fail and a percentage showing how much of the image each device rendered. A GPU showing fail or disabled, or a very low percentage, means you are not getting the speed you are paying for.
Also check that no environment variable is limiting devices: KARMA_XPU_DISABLE_OPTIX_DEVICE turns off all GPUs, and KARMA_XPU_DEVICES enables only the device IDs it lists. More in Karma XPU’s silent CPU fallback.
9. Fit the scene into each GPU’s memory
SideFX: “Each GPU device is addressed separately and memory is not pooled.” Four 32 GB cards do not give you 128 GB for one scene; each card has to hold it. If one GPU fails, for example by running out of memory, the other devices, including the CPU, “will pick up the load” and finish the frame. Textures load in tiles on demand; when GPU memory fills mid-render, XPU evicts non-essential memory and keeps going, but “the GPU will slow down significantly” in that state. Our guide to VRAM for Houdini GPU rendering helps size the scene.
10. Render a test frame from the command line with husk
Before you queue the whole range, render one frame with husk, the command-line renderer that batch jobs use. Its --engine option takes xpu or cpu; -f sets the start frame, -n the frame count and -o the output path:
husk --engine xpu -f 1001 -n 1 -o $HIP/render/test.$F4.exr scene.usd
On the USD Render ROP, Render Frame Range (Strict) renders only the frames inside the range you set. Compare the test frame with your interactive render before you commit hours of GPU time.
Sources: SideFX, husk; USD Render ROP.
SaaS or IaaS render farm for the Karma XPU pre-flight checks?
Which farm type fits your situation
Both models render Karma XPU; they differ in how much of the machine you control.
| Situation | Usually a better fit | Why |
|---|---|---|
| Standard MaterialX scene, all paths relative, cache already on disk | SaaS (managed farm) | Upload, submit and wait; the farm runs the nodes for you |
| You need to see the device list and render stats yourself | IaaS (remote workstation) | You open Houdini on the machine and check OptiX and EmbreeCPU status directly |
| Scene needs a specific Houdini build, driver or plugin version | IaaS | You install exactly the versions you tested with |
| Heavy textures or volumes close to the VRAM limit | IaaS with larger cards | You test on 32 GB cards and watch for eviction before the full run |
| Short one-off render with no time to set up a machine | SaaS | No setup time; you pay for the render job |
Rule of thumb: if every item on the checklist passes and you trust the scene, a managed farm is the quickest path. If you are still working on items 5, 8 or 9, a machine you control lets you fix the scene on the spot instead of re-uploading it.
A pre-flight run on an iRender server
On iRender you rent a whole Windows workstation, install your own Houdini build and sign in with your own SideFX license (see Houdini licenses for render farms), so the scene opens exactly as on your desk.
- Upload the project folder, with
$HIP-relative paths and caches, through iRender Drive. - Start a server. For Karma XPU we recommend the 4x RTX 5090 servers (32 GB per card); 8x servers also render, but Karma XPU does not get proportionally faster.
- Install the same Houdini and driver versions you use locally, then run Pre-compile Karma XPU Render Kernels.
- Open the scene, run Pre-Flight Scene and check that the device list shows four OptiX devices.
- Render one frame with husk, compare it with your local result, then render the range.
Before you render the sequence on another machine
Pre-flight checklists for other software: Cinema 4D & Redshift, Cinema 4D + Octane, Blender Cycles.
Frequently asked questions
1. Does Karma XPU combine the VRAM of several GPUs?
No. SideFX states that each GPU device is addressed separately and memory is not pooled, so every card must hold the scene.
2. What happens if one GPU runs out of memory during a Karma XPU render?
That device fails and the remaining devices, including the CPU, pick up the load and finish the frame, which is usually slower.
3. Can I use the Principled Shader with Karma XPU?
It is converted to USD Preview Surface automatically, with varying success. For predictable results use MaterialX or USD Preview Surface.
4. Which NVIDIA driver does Karma XPU need?
Driver 570 or later, with 575 or later strongly recommended on Windows, and a GPU with Compute Capability 5.0 or higher.
5. Why is my first Karma XPU render slow on a new machine?
The render kernels compile on first use after a new Houdini build or driver. Pre-compile them from the Render menu before you start.
6. Do I need my own Houdini license on iRender?
Yes. You install Houdini on the rented workstation and sign in with your own SideFX license.
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.
Sources: SideFX documentation: Karma XPU, Karma, Karma XPU kernel pre-compilation, Project ($HIP / $JOB), Dependencies window, husk, USD Render ROP. Checked November 2026.
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).


