Karma XPU OptiX Delay and Missing GPUs: Pre-compile Kernels and Check Every Device
Why Karma XPU pauses before the first pixel, and how to make sure every GPU is rendering:
- The pause is compiling: Karma XPU compiles its render kernels and your shaders for the OptiX device. SideFX says one kernel can take from a few seconds to several minutes, and the result is cached.
- Pre-compile only where it helps: Render > Pre-compile Karma XPU Render Kernels fills the cache for interactive work. The full run can take several hours, and SideFX notes that farm machines do not need it; they compile kernels as needed.
- Check every GPU in the render stats: each GPU shows up as its own OptiX device with a status and a share of the image. Karma XPU uses all compatible GPUs by default; a device marked fail is usually out of memory, on an old driver or disabled by an environment variable.
- On iRender: 4x RTX 5090 servers for Karma XPU, with your server image saved between sessions, so your Houdini install and kernel cache are still there next time.
Two problems come up again and again when artists move Houdini scenes to a multi-GPU machine. The first is the Karma XPU OptiX delay: the render sits at the start while OptiX compiles, sometimes for minutes. The second is a GPU that never joins the render, so a 4-GPU machine runs like a 2-GPU one.
This guide explains what Karma XPU is compiling and when pre-compiling is worth it, how to see which devices are rendering, and why a GPU drops out. Setting names, menu paths and environment variables come from the SideFX Houdini documentation; where an older guide (including an earlier version of this one) suggested commands that SideFX does not document, we have left them out.
Checked against the SideFX Karma XPU and pre-compile documentation and the Houdini system requirements, November 2026.
Why Karma XPU pauses before the first pixel
On startup, Karma XPU has to compile shaders into a format each device can run. SideFX describes this as a pause or stutter when you load a new scene or turn on a feature for the first time. Two kinds of code are compiled:
- Render kernels: the core XPU rendering code. Which kernels a scene needs depends on the features it uses, and SideFX says each one can take from a few seconds to several minutes to compile.
- User shaders: your materials and light filters. These cannot be pre-compiled, because Houdini cannot predict how your networks will be built, but they usually compile much faster than kernels.
Compiled kernels are cached on disk, so the long wait normally happens once. While OptiX is compiling, the render stats in the viewport say so; the message Compiled Render Kernel Cache out of Date means pre-compiling would cut the wait.
| What happened | Will Karma XPU compile again? | What to expect |
|---|---|---|
| First Karma XPU render after installing Houdini | Yes, every kernel the scene needs | The longest wait; later renders reuse the cache |
| You updated the NVIDIA driver | Yes, the cache is no longer valid | The same waits as a fresh install until the cache is rebuilt |
| You installed a new Houdini release | Yes, the cache is kept per major release | A new cache folder is filled for that version |
| You turned on a feature the scene did not use before | Only the new kernels | A shorter pause the first time that feature renders |
| You edited a material | Only that shader | Usually a short pause; shaders compile faster than kernels |
Based on SideFX’s Karma XPU and Karma XPU pre-compiling pages. An out-of-date cache does not change image quality; Karma XPU compiles the missing kernels on the fly.
Pre-compile the render kernels (and when not to)
Houdini can fill the kernel cache in advance. In the main menu choose Render > Pre-compile Karma XPU Render Kernels. A fresh installation also offers this the first time you create a Solaris LOP node. SideFX’s advice:
- Save your work first and free as many system resources as you can.
- The full run can take several hours, depending on the system. You can stop it and resume later; it continues where it left off.
- Only the OptiX GPU device benefits. The Embree CPU device does not need it, and neither does Karma CPU.
- The cache is stored per user and per major Houdini release, for example
C:\Users\USERNAME\AppData\Local\NVIDIA\OptixCache\Houdini21.0on Windows or/var/tmp/OptixCache_USERNAME/Houdini21.0on Linux. It can take several gigabytes. Deleting the folder sends Karma XPU back to compiling as it goes. - SideFX does not recommend sharing one cache over a network drive, because kernels are built for a specific system and GPU setup.
When not to bother: SideFX notes that farm machines do not need pre-compiling. They compile kernels as a scene needs them, and pre-compiling mainly makes interactive work smoother. If you only render a sequence, letting the first frame compile what it needs is usually cheaper than a full pre-compile that can run for hours.
How to read the figure. Compare the two ways to get compiled kernels. On demand, Karma XPU compiles OptiX kernels the first time a scene or feature is used, so the first pixel appears after a pause of seconds to minutes each time. With Render › Pre-compile Karma XPU Render Kernels, the compilation runs once, can take hours and can be stopped and resumed, and later renders start right away from the cache on that machine.
Check that Karma XPU is using every GPU
Karma XPU uses every compatible device it finds, including several GPUs, without any extra setting. Each NVIDIA GPU becomes its own OptiX device and the CPU becomes an EmbreeCPU device. The devices are listed in the top right of the viewport under the render progress, each with a status (idle, init, disabled or fail) and a percentage that shows how much of the current image it has rendered. For more detail, turn on Render Stats in the Guides tab of the viewport Display Options.
Two facts from the SideFX documentation explain most “missing GPU” reports. GPU memory is not pooled, so every GPU has to hold the scene on its own. And when a device fails, for example because a GPU runs out of memory, the other devices, including the CPU, pick up its work and the frame still finishes. The render does not stop, it just gets slower, which is why the device list is the first thing to check.
How to read the figure. On a healthy 4-GPU machine you should see four OptiX devices rendering, each with a similar share, and a much smaller share for EmbreeCPU. SideFX notes that the GPU devices contribute far more than the CPU device, because XPU is written for the GPU.
On a machine you will keep using, the setup comes down to four steps, numbered the same way in the figure:
- Save your work and free as many system resources as you can.
- Run Render › Pre-compile Karma XPU Render Kernels; it can take hours and can be resumed.
- Turn on Render Stats in the Guides tab of Display Options.
- Read the device list: each OptiX GPU and the EmbreeCPU device with a status and its share of the image.
How to read the figure. The badges match the four steps above. On the left, badge 1 is the preparation before the long compile and badge 2 is the Pre-compile command in the Render menu. On the right, badge 3 is Render Stats in Display Options and badge 4 is the device list, where every OptiX GPU should show a status and a share of the image.
Why a GPU drops out of a Karma XPU render
| What you see | Likely cause | What to do |
|---|---|---|
| No OptiX devices at all, only EmbreeCPU | NVIDIA driver older than 570, or a GPU below Compute Capability 5.0 | Update the driver; SideFX strongly recommends 575 or later on Windows |
| OptiX devices show disabled | An environment variable such as KARMA_XPU_DISABLE_OPTIX_DEVICE, or a KARMA_XPU_DEVICES list without optix, in your environment, a package file or houdini.env | Remove or correct the variable and restart Houdini |
| One or more GPUs show fail partway through | The GPU ran out of memory; memory is not pooled across GPUs | Reduce what the scene loads on the GPU, or use GPUs with more memory; for heavy curves, KARMA_XPU_OPTIX_CURVE_OPT_LEVEL=1 uses less memory |
| All GPUs render, but slowly late in the frame | GPU memory filled and Karma XPU started evicting texture tiles | Check eviction in the render stats; SideFX says the GPU slows down significantly in this state |
| Every frame starts with a long pause | Kernels are compiling (first render, new driver or new Houdini release) | Let it finish once, or pre-compile for interactive work |
Device statuses, driver versions and variables from SideFX’s Karma XPU documentation.
Fix the cause, then restart the render and check the device list again. If one GPU keeps failing on a scene that fits the others, test it alone: SideFX’s device variables below let you turn devices on and off.
Karma XPU device variables, and what they really do
You can set these in your system environment, in a JSON package or in houdini.env. They switch devices on and off; none of them makes Karma XPU find a GPU it cannot use.
| Variable | Effect (SideFX) | Use it to |
|---|---|---|
| KARMA_XPU_DEVICES | A comma-separated list of the devices to enable; KARMA_XPU_DEVICES=optix uses only the OptiX GPU engine | Render GPU-only, so a failing GPU is not hidden by the CPU |
| KARMA_XPU_DISABLE_EMBREE_DEVICE | If set, Karma XPU creates no Embree CPU devices | The same GPU-only test |
| KARMA_XPU_DISABLE_OPTIX_DEVICE | If set, Karma XPU creates no OptiX GPU devices | Render on the CPU device only, to compare the result |
| KARMA_XPU_OPTIX_CURVE_OPT_LEVEL | Trades memory for speed on curves: 1 = low memory, 2 = mid (default), 3 = high memory | Fit hair and fur scenes into GPU memory |
| KARMA_XPU_OPTIX_SPARSE_TEXTURES | Used to disable sparse (tiled) texture loading | Troubleshoot texture streaming |
From SideFX’s Karma XPU documentation (Houdini 21.0).
A common mistake is setting KARMA_XPU_DEVICES=optix to “force all GPUs”. Karma XPU already uses all supported GPUs. What the setting does is remove the CPU device, which is useful for testing: when a GPU fails, nothing takes over quietly, so the failure becomes obvious. Remember to remove it afterwards if you want the CPU to help.
SaaS or IaaS render farm for Karma XPU on several GPUs?
Both farm models produce the same frames, and on both the first render on a machine has to compile what the scene needs. The difference is how much of the machine you can see: whether you can open the render stats, check each device and keep a kernel cache between sessions.
| Your situation | SaaS render farm | IaaS render farm (iRender) |
|---|---|---|
| The scene is approved and fits in GPU memory | 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 need to see that every GPU is rendering | You see the farm’s logs and the finished frames. | Open the viewport render stats on the server and watch each OptiX device and its share live. |
| One GPU keeps failing on a heavy frame | Each test is a job: change the scene, submit, wait and read the log. | Test with KARMA_XPU_DEVICES=optix on the server, change the scene and render again straight away. |
| First-render compile time | Farm machines compile kernels as each job needs them, which SideFX describes as normal for farms. | The kernel cache sits in your user folder on your saved image, so it is reused next session until the driver or Houdini release changes. |
A comparison of how the two farm models work for this task, not a speed test.
A simple rule: if the scene is approved, fits in GPU memory and you only need frames, a SaaS farm is a good fit. If you need to see that every GPU is rendering, find out why one fails, or work interactively in Solaris on the render hardware, use an IaaS server.
A Karma XPU check on an iRender server
How to read the figure. The left box is your own workstation and the right box is the iRender server: the same desktop, Houdini version, plugins, licenses and render settings. The only difference is the GPU count, from 1 to 8 RTX 5090 or RTX 4090, so the scene renders on the server the way it does at home.
- Upload the project and caches to iRender Drive before you start the server; uploading is free and does not use rental time.
- Start a 4x RTX 5090 server. In our experience Karma XPU runs best on 4 GPUs. Billing is per minute.
- Install Houdini and sign in with your own SideFX license. Houdini is not pre-installed; your server image is saved between sessions, so you install it once.
- Open the scene and render one frame with Render Stats on. Let the first compile finish, and check that four OptiX devices are rendering.
- Render the sequence with husk or the Render Product as usual. 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; the kernel cache and USD behaviour are tied to it.
- Check the NVIDIA driver is version 570 or later (575 or later recommended on Windows); current drivers are on NVIDIA’s driver page.
- Remove any KARMA_XPU test variables you set while troubleshooting, unless you mean to keep them.
- Make sure the heaviest frame fits in one GPU’s memory: 32 GB on an RTX 5090. Memory is not added up across GPUs.
- Render the heaviest frame first with Render Stats on, and confirm every GPU is contributing before you start the full range.
Frequently asked questions
1. Why does Karma XPU take so long to start rendering?
Karma XPU compiles its render kernels and your shaders for the OptiX GPU device before it can render. SideFX says a single kernel can take from a few seconds to several minutes. The compiled kernels are cached, so the long wait usually happens only the first time, after a driver update or after installing a new Houdini release.
2. How do I pre-compile Karma XPU render kernels?
In Houdini’s main menu choose Render, then Pre-compile Karma XPU Render Kernels. Save your work first. The full run can take several hours, and you can stop it and continue later. SideFX notes that farm machines do not need it, because they compile kernels as each scene needs them.
3. Where is the Karma XPU kernel cache stored?
On Windows it is in C:\Users\USERNAME\AppData\Local\NVIDIA\OptixCache\ followed by a folder for the Houdini release, such as Houdini21.0. On Linux it is in /var/tmp/OptixCache_USERNAME/. Deleting that folder makes Karma XPU compile kernels again as it renders.
4. Does Karma XPU use all my GPUs automatically?
Yes. Karma XPU uses every compatible NVIDIA GPU it detects, each as its own OptiX device, plus the CPU as an EmbreeCPU device. Check the device list in the viewport render stats: each device shows a status and its share of the image.
5. Does KARMA_XPU_DEVICES=optix make Karma use more GPUs?
No. It tells Karma XPU to use only the OptiX GPU engine and not the CPU device. That is useful for troubleshooting, because a failing GPU is no longer hidden by the CPU taking over its work, but it does not add GPUs that Karma could not already use.
6. Why does one of my GPUs show fail in Karma XPU?
Most often the GPU ran out of memory. Memory is not pooled across GPUs, so each card must hold the scene on its own. The other devices finish the frame, so the render continues but slower. Other causes are an NVIDIA driver older than 570 or an environment variable that disables the device.
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.


