October 22, 2026 Kelly Nguyen

Karma XPU OptiX Delay and Missing GPUs: Pre-compile Kernels and Check Every Device

Executive SummaryKey Takeaways: Karma XPU OptiX Delay and Multi-GPU Checks
Houdini Solaris / Karma XPU

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 happenedWill Karma XPU compile again?What to expect
First Karma XPU render after installing HoudiniYes, every kernel the scene needsThe longest wait; later renders reuse the cache
You updated the NVIDIA driverYes, the cache is no longer validThe same waits as a fresh install until the cache is rebuilt
You installed a new Houdini releaseYes, the cache is kept per major releaseA new cache folder is filled for that version
You turned on a feature the scene did not use beforeOnly the new kernelsA shorter pause the first time that feature renders
You edited a materialOnly that shaderUsually 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.0 on Windows or /var/tmp/OptixCache_USERNAME/Houdini21.0 on 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.

iRender
Pre-compiling Karma XPU kernels
OPTIX
Compiled on demandthe first time a scene or feature is usedStart rendercompile kernelsseconds to minutes eachrenderfirst pixel after the pausePre-compiledRender › Pre-compile Karma XPU Render KernelsRun oncepre-compile all kernelshours; can stop and resumecacheStart renderrenderfirst pixel starts right awaySideFX: save your work and free as many system resources as you can firstWorth it on a machine you keep using; on a one-off machine let it compile only what the scene needs
CompilePre-compileRender
From SideFX

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.

iRender
How Karma XPU uses several devices
device view
OptiX device 0RTX 5090 · own 32 GBsceneOptiX device 1RTX 5090 · own 32 GBsceneOptiX device 2RTX 5090 · own 32 GBsceneOptiX device 3RTX 5090 · own 32 GBfullstatus: fail(e.g. out of GPU memory)EmbreeCPU deviceOne frameall working devices add samplesRender stats:device list,status, share %✓ Memory is not pooled: every GPU holds the scene on its own. If one device fails, the others (and the CPU) finish the frame.A failed GPU does not stop the render, so check the device list to see that all GPUs are contributing.
OptiX GPU devicesEmbreeCPU deviceFailed device
Schematic, not to scale

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:

  1. Save your work and free as many system resources as you can.
  2. Run Render › Pre-compile Karma XPU Render Kernels; it can take hours and can be resumed.
  3. Turn on Render Stats in the Guides tab of Display Options.
  4. Read the device list: each OptiX GPU and the EmbreeCPU device with a status and its share of the image.
iRender
Pre-compiling kernels and checking every GPU: four steps
D1
Before you startsave your work, free system resources1Render menuPre-compile Karma XPU Render Kernels2can take hours; can be stopped and resumedDisplay Options › GuidesRender Stats3Device list, top right of the viewportOptiX (each GPU)status and share of the image4EmbreeCPUstatus and share
Step to follow
Mockup based on SideFX documentation

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 seeLikely causeWhat to do
No OptiX devices at all, only EmbreeCPUNVIDIA driver older than 570, or a GPU below Compute Capability 5.0Update the driver; SideFX strongly recommends 575 or later on Windows
OptiX devices show disabledAn 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.envRemove or correct the variable and restart Houdini
One or more GPUs show fail partway throughThe GPU ran out of memory; memory is not pooled across GPUsReduce 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 frameGPU memory filled and Karma XPU started evicting texture tilesCheck eviction in the render stats; SideFX says the GPU slows down significantly in this state
Every frame starts with a long pauseKernels 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.

VariableEffect (SideFX)Use it to
KARMA_XPU_DEVICESA comma-separated list of the devices to enable; KARMA_XPU_DEVICES=optix uses only the OptiX GPU engineRender GPU-only, so a failing GPU is not hidden by the CPU
KARMA_XPU_DISABLE_EMBREE_DEVICEIf set, Karma XPU creates no Embree CPU devicesThe same GPU-only test
KARMA_XPU_DISABLE_OPTIX_DEVICEIf set, Karma XPU creates no OptiX GPU devicesRender on the CPU device only, to compare the result
KARMA_XPU_OPTIX_CURVE_OPT_LEVELTrades memory for speed on curves: 1 = low memory, 2 = mid (default), 3 = high memoryFit hair and fur scenes into GPU memory
KARMA_XPU_OPTIX_SPARSE_TEXTURESUsed to disable sparse (tiled) texture loadingTroubleshoot 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 situationSaaS render farmIaaS render farm (iRender)
The scene is approved and fits in GPU memoryA 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 endsJobs join the farm’s queue, so the start time depends on how busy the farm is; many farms sell higher-priority plans to start soonerThe 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 renderingYou 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 frameEach 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 timeFarm 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

iRender
Works 1:1 like your own PC: we keep your setup, you just get more GPUs
IaaS render farm
Your workstationscene.c4d · .blend · .hip1 GPUYour iRender serverscene.c4d · .blend · .hipup to 8 GPUs=same setupWindows or Ubuntu desktopYour software, in the version you chooseYour plugins and scriptsYour licensesYour scene and render settings, unchanged1 GPUGPU power: the only difference1, 2, 4 or 8 × RTX 5090 / 4090✓ Only the GPU count changes: open your scene and render the way you do at home
Same on both machinesTip: upload the full project folder with relative paths so textures are found

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.

  1. Upload the project and caches to iRender Drive before you start the server; uploading is free and does not use rental time.
  2. Start a 4x RTX 5090 server. In our experience Karma XPU runs best on 4 GPUs. Billing is per minute.
  3. 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.
  4. Open the scene and render one frame with Render Stats on. Let the first compile finish, and check that four OptiX devices are rendering.
  5. 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.

Accelerate your production pipeline with high-performance IaaS render farm services and dedicated bare-metal workstations powered by 4x NVIDIA GeForce RTX 5090 (32GB GDDR7), high-frequency AMD Ryzen™ Threadripper™ PRO processors, 256GB ECC RAM, and dedicated 2TB NVMe SSD storage tailored for your pipeline:
, , , , , , ,

Kelly Nguyen

Kelly Nguyen is a customer support specialist at iRender who helps artists render Houdini, Blender and Cinema 4D projects on multi-GPU servers, and writes practical GPU rendering guides for the iRender blog.
Contact

iRENDER GPU

Render Farm Pricing
Quick Start
Multi-GPU Benchmarks
iRender GPU App
Blog
Documentation
The Render Farm
The Company
Terms & Conditions

INTEGRATIONS

Autodesk Maya
Blender
Cinema 4D
Houdini
Karma XPU
Lumion
KeyShot
Unreal Engine
Twinmotion
Redshift
Octane
And many more…

iRENDER TEAM

Elite support 7 days a week
SATURDAY – SUNDAY: 6:00 AM – 11:59 PM
(UTC+7)
Hotline: (+84) 912-785-500
Skype: iRender Support
Email: [email protected]
Address 1: 68 Circular Road #02-01, 049422, Singapore.
Address 2: No.22 Thanh Cong Street, Hanoi, Vietnam.

Contact
이 페이지는 한국어로도 제공됩니다. 한국어로 보기 →