Houdini TOPs for Rendering: USD Render Node, Batches and Resume
TOPs turns a frame range into work items, sends each one to husk through a scheduler, and skips frames that already exist. The settings that matter most:
- Node: USD Render Scene renders a LOP network or a .usd file
- Batches: Frames per Batch 1 = one job per frame; higher values group frames
- Resume: Cache Mode Automatic skips frames already on disk
- Scheduler: Local Scheduler: one Karma XPU job at a time, retries on failure
- Debug: Create Husk Command Attribute shows the exact command each job ran
A ROP render is one long process: if it stops at frame 63, you have to work out which frames are missing and start again. TOPs (PDG) treats every frame as a separate work item with its own status, log and output file, so a scheduler can retry failures, skip finished frames and run the same network on a workstation, on HQueue or on Deadline.
This guide covers the TOP nodes that render USD with husk, how work items and batches are formed, Local Scheduler settings for a multi-GPU machine, and how to resume a sequence. It is the TOPs companion to our husk command-line guide.
Checked against the SideFX Houdini 22 node help for USD Render, USD Render Scene and Local Scheduler, November 2026.
Which TOP node renders USD
Two TOP nodes render USD, and both run the Houdini husk executable for each job:
- USD Render Scene can render a LOP network in the current scene or a .usd file on disk, and reads the output paths from the USD hierarchy. With Input USD = LOP Node it writes the network to disk first.
- USD Render Files only renders USD files that already exist, for example files written upstream.
Karma is the default delegate; the Render Delegate parameter selects another Hydra client. Both nodes expose the usual render settings prim, camera and resolution overrides.
The diagram shows the part that saves the most time: with Cache Mode set to Automatic, a work item whose expected output already exists on disk is marked as cooked without being scheduled. Rerunning the network after a crash therefore renders only what is missing.
Sources: USD Render Scene, USD Render Files.
Work items and batches
Evaluate Using decides how work items are created: Single Frame makes one work item per upstream item, Frame Range uses a start, end and step, and Custom Range takes a value pattern. By default each work item is cooked as a separate job.
Frames per Batch groups work items so one husk process renders several frames, and All Frames in One Batch sends the whole range as a single job. Fewer jobs mean fewer process starts, but a retry then covers the whole batch, and SideFX notes a limitation for batched renders: husk cannot evaluate work item attributes in file paths when it renders several frames. For Karma XPU sequences, one frame per job is the safest starting point; try small batches only if process start-up is a large share of each frame.
Sources: USD Render TOP.
Scheduling renders on one multi-GPU workstation
The Local Scheduler runs work items on the machine Houdini is running on. Its defaults are tuned for CPU work such as simulations, where several jobs run side by side. A Karma XPU job already uses every GPU it can see, and each GPU holds its own copy of the scene, so two renders on the same GPUs compete for the same VRAM.
Local Scheduler settings that matter for GPU renders
All parameter names are from the Houdini 22 Local Scheduler help.
| Parameter | What it does | For Karma XPU jobs |
|---|---|---|
| Total Slots | Number of slots the scheduler can use at once | Keep render jobs to one at a time: each XPU job already uses every GPU |
| Slots per Work Item | How many slots one job consumes | Alternative way to stop two renders sharing the GPUs |
| Single | Runs only one work item at a time | Simplest switch for a render-only network |
| On Task Failure / Maximum Retries | Report, warn, retry or ignore a failed job | Retry once or twice to ride out a driver hiccup |
| Minimum Available Memory | RAM required before a job starts | Avoids starting a frame the machine cannot hold |
| Maximum Memory | RAM cap per work item, then mark failed or succeeded | Stops one runaway frame from freezing the machine |
| Environment Variables | Extra variables for every work item | Pass KARMA_XPU_* settings to all jobs |
Set the scheduler so only one render job runs at a time, add a retry, and set a memory cap below the machine RAM. On a farm, the HQueue, Deadline and Tractor schedulers apply the same idea per render node.
Put Karma XPU environment variables, such as KARMA_XPU_DISABLE_EMBREE_DEVICE, in the scheduler’s Environment Variables list so every job gets them. Variables are documented on the SideFX Karma XPU page.
Sources: Local Scheduler, Karma XPU.
Checkpoints, time limits and resuming a sequence
Three settings on the USD Render node make long sequences safer:
- Cache Mode = Automatic: finished frames are never rendered twice. Use Write Files only when you want to overwrite everything.
- Checkpoint Interval: writes a checkpoint file and a partial image every N seconds, so a long frame can be inspected and, for Karma, picked up again instead of starting from zero.
- Time Limit: cancels a frame after N seconds; No Partial Results on Timeout decides whether the unfinished image is kept.
If you drive husk directly instead, --skip-existing-frames gives the same resume behaviour as Cache Mode.
Sources: USD Render TOP, husk.
Finding out what a job actually ran
When a frame fails on a farm but works locally, compare the commands. Turn on Create Husk Command Attribute and each work item gets a huskcommand attribute with the full command its job executed; copy it into a terminal on the render machine to reproduce the error. The outputimage attribute holds the output path pattern.
Extra Husk Arguments passes flags the node has no parameter for, for example -V 2e for elapsed times in the log. Command Override runs a wrapper script instead of husk and passes it the generated command, which is useful to set per-job environment variables. For the Karma XPU checks to run before any of this, see the Karma XPU pre-flight checklist.
Sources: USD Render TOP.
SaaS or IaaS render farm for a TOPs render network?
Which farm type fits a TOPs workflow
Both can render the frames; they differ in whether your TOP network runs as you built it.
| Situation | Usually a better fit | Why |
|---|---|---|
| Plain frame range, no wedges or custom steps | SaaS (managed farm) | Submit the scene; the farm splits and schedules frames |
| Network with wedges, file checks or post-render steps | IaaS (remote workstation) | Your TOP network runs unchanged, including custom Python or HDAs |
| You want to tune scheduler slots, retries and memory caps | IaaS | You edit the Local Scheduler on the machine that renders |
| Debugging a frame that fails only on another machine | IaaS | You can copy @huskcommand into a terminal on that machine |
| Small one-off render | SaaS | No setup time |
Rule of thumb: a managed farm suits a straight frame range. If your network does more than render (wedges, checks, conversions), a machine you control runs it exactly as you built it.
Running a TOPs render on an iRender server
On iRender you rent a whole Windows workstation with your own Houdini installed, so the TOP network runs with the Local Scheduler just as it does on your desk:
- Upload the project with $HIP-relative paths and caches through iRender Drive.
- Start a 4x RTX 5090 server, which we recommend for Karma XPU; 8x servers also render Karma XPU, but it does not get proportionally faster.
- Install your Houdini build and sign in with your own SideFX license. The Karma XPU kernels compile on the first render and the cache stays on your saved server image.
- Set the Local Scheduler to one render job at a time with a retry, and turn on Cache Mode Automatic.
- Cook the network; if the session is interrupted, cook it again and only the missing frames render.
TOPs render checklist
Use this as a final check before you start the full range on any machine.
Frequently asked questions
1. Which TOP node should I use to render Karma?
USD Render Scene renders a LOP network or a .usd file; USD Render Files renders .usd files only. Both run husk for each job.
2. How do I make TOPs skip frames that are already rendered?
Set Cache Mode to Automatic. A work item whose expected output exists on disk is marked as cooked without being scheduled.
3. Should I batch frames for Karma XPU?
Start with Frames per Batch 1. Batching reduces process starts, but a retry then covers the whole batch and husk cannot evaluate work item attributes in paths for batched frames.
4. Why should only one render job run at a time on a GPU machine?
Karma XPU uses every GPU it detects and memory is not pooled, so two jobs on the same GPUs each need room for a full copy of the scene.
5. How do I see the exact husk command a work item ran?
Turn on Create Husk Command Attribute. The full command is stored in the huskcommand attribute.
6. Does TOPs need a Houdini license on the render machine?
The Houdini session that cooks the network needs a Houdini or Engine license; the husk jobs themselves render with a Karma license. See SideFX’s licensing pages for your edition.
7. What is Frames per Batch in the USD Render TOP?
It groups work items so one husk process renders several frames. The default of 1 cooks each work item as a separate job.
8. How do I pass extra husk flags from TOPs?
Use the Extra Husk Arguments parameter on the USD Render node, for example -V 2e for elapsed times in the log.
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: USD Render TOP, USD Render Scene TOP, Local Scheduler TOP, husk, Karma XPU, husk licenses (SideFX FAQ). 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).


