Why the First Karma XPU Frame Is Slow: Kernels, USD Loading and Textures
A slow first frame is usually set-up, not rendering. The usual causes on a new machine:
- Kernels: XPU compiles render kernels on first use: up to 1–2 minutes on a new install or driver
- Cache: compiled kernels are cached per machine and per major Houdini release
- Pre-compile: optional; the full set can take hours; farm machines compile as needed
- Loading: husk loads the USD and textures before sampling; bandwidth peaks here
- Measure: husk -V with t timestamps shows which stage is slow
On a fresh render machine, the first Karma XPU frame can take far longer than the rest of the sequence, and the GPUs sit almost idle while it happens. That time goes into compiling render kernels for this exact GPU and driver, loading the USD stage and textures, and building the scene, not into sampling.
This guide explains each stage, when kernel compilation happens and when it does not, how the kernel cache works, whether pre-compiling is worth it on a render machine, and how to measure where the time goes.
Checked against the SideFX Houdini 22 documentation (Karma XPU, Pre-compile Karma XPU render kernels, Inside husk, husk, What’s new in Karma), November 2026.
What happens before the first pixel
Before Karma XPU samples a single pixel it has to load the USD stage, load textures, compile its render kernels if they are not cached, and build or dice the geometry. SideFX notes that bandwidth peaks when husk loads the USD files and textures; on a render machine with network storage this stage alone can dominate short frames.
Kernel compilation happens only when there is no valid cached kernel; the other stages repeat for every frame in a new process. That is why the first frame is slow and the second is fast in the same husk process.
Sources: Karma XPU, Inside husk.
Kernel compilation and the kernel cache
On startup, Karma XPU compiles shaders into device-specific formats, which causes a pause when a scene loads or a feature is enabled for the first time. SideFX says the first compilation can take up to 1–2 minutes on a new installation of Houdini or a new GPU driver, and that the results are cached, so rendering the same scene does not pause again.
The cache is stored per major Houdini release, under AppData\Local\NVIDIA\OptixCache on Windows and /var/tmp/OptixCache_USERNAME on Linux. Kernels are compiled to very specific system and GPU specifications, so SideFX does not recommend sharing the cache over a network drive. When the cache is out of date, the viewport shows a message; render quality is unaffected, but XPU compiles the missing kernels on the fly.
Sources: Pre-compile Karma XPU render kernels, Karma XPU.
Should you pre-compile on a render machine?
Houdini 21 added Pre-compile Karma XPU Render Kernels in the Render menu to reduce the time to first pixel. SideFX describes it as entirely optional: it optimises only the OptiX device, is not needed for Karma CPU, and cannot pre-compile user shaders. Each kernel can take from a few seconds to several minutes, the full pre-compile can take several hours, and you can interrupt it and resume later.
SideFX also says farm machines do not need pre-compiling, because they compile kernels as needed. In practice:
- A machine that renders one sequence once: let the first frame compile what the scene needs; a full pre-compile costs more than it saves.
- A machine you keep and reuse (a workstation, or a rented server whose disk image is kept between sessions): the cache survives, so later sessions start without the pause.
- After a driver or Houdini update: expect the first frame to compile again.
Sources: Pre-compile Karma XPU render kernels, What’s new in Houdini 21: Karma.
Faster USD and texture loading
- Keep the project on local disk of the render machine rather than streaming it over a network share during the render.
- Use tiled, mipmapped textures. Karma XPU loads textures on demand in tiles; Houdini 22 improved mipmap loading on indirect bounces, and the Karma Texture Baker can now save mipmapped textures for efficient rendering.
- Trim unused data. Houdini 22’s texture conversion adds
--opaque-detect, which saves bandwidth and memory without changing the render, and data deduplication (Houdini 21) avoids loading identical geometry twice. - Render several frames per process where your pipeline allows, so loading is not repeated for every frame; see our TOPs batching guide.
Sources: Karma XPU, What’s new in Houdini 22: Karma.
Measure before you change anything
husk’s verbosity flag takes a level plus letters: t adds timestamps and e elapsed time. Render the first two frames in one process and compare: the difference between frame 1 and frame 2 is start-up, and the gap between the timestamps tells you which stage takes it.
If the slow stage is kernel compilation, it disappears on the next run on the same machine. If it is loading, look at storage and texture formats. If it is building the scene, look at dicing and instancing; our guides to displacement and dicing and point instancing cover those.
Sources: husk.
SaaS or IaaS render farm when start-up time matters?
Which farm type keeps start-up time low
Both pay start-up time; they differ in whether caches survive between jobs.
| Situation | Usually a better fit | Why |
|---|---|---|
| Long frames where a minute of start-up does not matter | SaaS (managed farm) | Start-up is a small share of each frame |
| Short frames where start-up dominates | IaaS (remote workstation) | Render many frames per process on a machine you keep |
| Repeated jobs on the same Houdini and driver | IaaS with a saved disk image | The kernel cache from the last session is still there |
| Large texture sets | IaaS | Textures stay on the machine’s local disk between sessions |
| One-off short job | SaaS | No setup time |
Rule of thumb: if each frame takes many minutes, start-up hardly matters. If frames are short or you render the same project repeatedly, a machine whose disk is kept between sessions avoids paying start-up again.
Shorter start-up on an iRender server
On iRender you rent a whole Windows workstation and your server image is saved between sessions, so Houdini, your textures and the Karma XPU kernel cache stay installed:
- Upload the project once through iRender Drive and keep it on the server’s local disk.
- Start a 4x RTX 5090 server (32 GB per card), which we recommend for Karma XPU; 8x servers also render Karma XPU, but it does not get proportionally faster.
- Install your Houdini build and driver; render one frame so the kernels the scene needs are compiled and cached.
- Time the first two frames with -V 3t and check which stage dominates.
- Render the range; later sessions on the same image start without the compile pause.
First-frame checklist
Use this as a final check before you start the full range on any machine.
Frequently asked questions
1. Why is my first Karma XPU frame so slow?
XPU compiles render kernels for the GPU and driver on first use, and loads the USD and textures. SideFX says the first compile can take up to 1–2 minutes on a new install or driver.
2. Where is the Karma XPU kernel cache?
Per major Houdini release: under AppData\Local\NVIDIA\OptixCache on Windows and /var/tmp/OptixCache_USERNAME on Linux.
3. Do I need to pre-compile Karma XPU kernels on a render farm?
No. SideFX describes pre-compiling as optional and says farm machines compile kernels as needed. The full pre-compile can take several hours.
4. Can I copy the kernel cache to other machines?
SideFX does not recommend sharing it over a network drive; kernels are compiled to very specific system and GPU specifications.
5. When do kernels compile again?
After a new Houdini installation or a GPU driver update, or when the scene uses kernels that are not cached yet.
6. How do I see which stage is slow?
Render two frames in one husk process with -V and the t flag for timestamps, and compare the stages.
7. Does pre-compiling help Karma CPU?
No. SideFX says pre-compiling optimises only the OptiX device and is not needed for Karma CPU.
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: Karma XPU, Pre-compile Karma XPU render kernels, Inside husk, husk, What’s new in Houdini 21: Karma, What’s new in Houdini 22: Karma. 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).


