Houdini husk Command-Line Rendering: Frame Ranges, Tiles and 4 GPUs
husk is the renderer behind the USD Render ROP and the TOPs USD Render node. Knowing its flags lets you run, split and resume a Karma XPU job without opening Houdini:
- Range: -f start, -n count, -i step, or --frame-list
- Resume: --skip-existing-frames after a crash
- GPUs: one process uses every GPU; memory is not pooled
- Split: one husk per GPU with CUDA_VISIBLE_DEVICES, or tiles for one big still
- License: husk with Karma checks out a Karma license; Python callbacks check out Engine
When you press Render on a USD Render ROP, Houdini writes the LOP network to a temporary USD file and starts an external process, husk, to render it. Batch jobs, TOPs and most farm submitters use the same tool. Running husk yourself gives you full control over which frames render, in which order, on which GPU, and what happens after a crash.
This guide covers the husk flags a farm job really needs, two ways to use a 4-GPU server, tiled rendering for large stills, and how to read the logs. Everything is checked against the Houdini 22 documentation.
Checked against the SideFX Houdini 22 documentation (husk, Inside husk, Karma XPU, USD Render ROP), November 2026.
What husk is and why every Houdini farm uses it
SideFX describes husk as a delegate-agnostic command-line tool that processes and controls the whole rendering task. It loads a USD file, picks a Hydra render delegate (Karma by default; Redshift and other delegates also plug in) and writes the render products defined in the USD render settings.
The USD Render ROP is a thin wrapper around it: the ROP writes the USD generated by the LOP network to a temp file, then launches husk to render an image or image sequence. The TOPs USD Render node does the same per work item. So a command that works in a terminal also works on a farm.
Licensing is simple to plan. According to SideFX, husk only checks that a Houdini license exists; rendering with the Karma delegate (CPU or XPU) checks out a Karma license, and running Python callbacks through husk checks out an Engine license for as long as the script runs. SideFX also counts licenses per machine rather than per application. See Houdini licenses for render farms for the full list.
Sources: Inside husk, USD Render ROP, SideFX FAQ: husk licenses, Licensing system.
The split in the diagram is what makes husk useful on a farm: once the USD file is written, the render needs only husk, the delegate and the licences on the right, not an interactive Houdini session.
The husk flags a frame-range job needs
A Karma XPU sequence on one machine usually needs only the start frame, the frame count, the output path and the USD file. The table lists the flags worth knowing; the command after it is a complete job.
The husk options a farm job actually uses
Every flag below is listed on the Houdini 22 husk page.
| Flag | What it does | When you need it |
|---|---|---|
| -f / -n / -i | Start frame, number of frames (start included), frame increment | Every sequence job; -i lets several processes share one range |
| --frame-list | Space-separated list of frames; overrides -f, -n and -i | Re-rendering a handful of bad frames |
| -o / --make-output-path | Output path; create missing folders | Fresh output folders on a new machine |
| --skip-existing-frames | Skips frames whose render products already exist on disk | Restarting a job after a crash or a reboot |
| --engine xpu|cpu | Overrides the Karma engine | Forcing XPU even if the USD says CPU |
| -s / -c / -r / -p | Render settings prim, camera, resolution, pixel samples | Overriding what is stored in the USD file |
| -V level | Verbosity 0–9; add e for elapsed time, t for timestamps, a for Alfred-style progress | Logs you can read the next morning |
| --timelimit / --snapshot | Cancel after N seconds; save a partial image every N seconds | Previews and long frames you want to watch |
Two flags save the most time on a farm. --skip-existing-frames skips frames whose files already exist for all render products, so after a crash you rerun the same command and only the missing frames render. --make-output-path creates the output folders, which are often missing on a fresh render machine.
-V 2e keeps the default verbosity and adds elapsed time to each log line, which is the quickest way to compare frame times later. Quote paths that contain spaces.
Sources: husk, What’s new in Houdini 22: Karma.
Using a 4-GPU server: one husk process or four
Karma XPU uses every compatible device it can detect, including multiple GPUs, and each GPU holds its own copy of the scene because memory is not pooled. One husk process therefore renders each frame on all four GPUs together. That is the simplest setup and it is the right default.
The alternative is to start four husk processes, each limited to one GPU and rendering every fourth frame. The diagram shows the trade-off.
Option A keeps one copy of the USD stage in system RAM and finishes frames one after another. Option B renders four frames at the same time but loads the stage four times, so it needs roughly four times the RAM for scene data, and each process prints its own log. Which one finishes the sequence sooner depends on the scene, so test both on a few frames before you commit: compare the elapsed times in the logs. We do not publish a speed-up figure here because it varies from scene to scene.
Limiting each process to one GPU
husk has no flag to choose a GPU. Karma XPU reads environment variables instead: KARMA_XPU_DISABLE_OPTIX_DEVICE, KARMA_XPU_DISABLE_EMBREE_DEVICE and KARMA_XPU_DEVICES, which takes a comma-separated list of device IDs. The standard CUDA variable CUDA_VISIBLE_DEVICES limits which NVIDIA GPUs a process can see. The batch files below use it, and disable the Embree CPU device so four processes do not also compete for CPU cores.
Disabling the Embree device has one side effect: XPU normally lets the CPU and the other GPUs finish a frame when one device fails, so with a single GPU and no CPU device a failure stops that frame instead of slowing it down. Check each log for the device list at startup to confirm every process sees exactly one OptiX device. If a GPU drops out, our guide to multi-GPU initialization failures in Karma XPU covers the usual causes.
Sources: Karma XPU, NVIDIA CUDA environment variables.
Large stills: render tiles and stitch them
For a single very large frame, husk can split the image into tiles. --tile-count 4 3 divides it into a 4 x 3 grid and --tile-index picks the tile to render, starting at 0. Each tile can go to a different machine or a different GPU.
SideFX ships itilestitch to combine the tiles and idenoise to denoise from the command line; both sit in the Houdini bin folder. Denoise the stitched image, not the tiles, because per-tile denoising can leave visible seams. On one machine, --autotile does the split and the stitch for you: husk loads the USD file once and stitches the tiles after rendering.
Tiling also helps with memory. Karma allocates its render vars (AOV buffers) in VRAM and RAM, and SideFX notes that a scene with 15 AOVs needs at least 1.5 GB for frame buffers alone. Deep output from Karma XPU requires tiling, because XPU has no bucket mode.
Sources: Inside husk, husk.
Logs, snapshots and time limits
Long frames are easier to manage when husk writes progress you can check from another machine:
- Verbosity:
-Vtakes 0–9, plusefor elapsed time,tfor timestamps andafor Alfred-style progress that many queue managers parse. - Snapshots:
--snapshot 300saves a partial image every 300 seconds, so you can inspect a frame before it finishes. On Linux, sending SIGUSR1 to the process writes one on demand. - Time limits:
--timelimitcancels the render after N seconds;--timelimit-imageapplies the limit to each image instead of the whole sequence. - New in Houdini 22:
--karma-percent-of-samplesstops a Karma render at a percentage of its samples,--enable-usd-errorsshows USD warnings that are normally hidden, and--error-summarywas added for error reporting.
Before you queue a full range, render one frame with the exact command the job will use and compare it with your interactive render. The Karma XPU pre-flight checklist lists the other checks.
Sources: husk, What’s new in Houdini 22: Karma.
SaaS or IaaS render farm for husk jobs?
Which farm type fits a husk workflow
Both can render USD with husk; they differ in who writes and runs the command.
| Situation | Usually a better fit | Why |
|---|---|---|
| You submit a .hip or .usd and want frames back | SaaS (managed farm) | The farm builds the husk command and queue for you |
| You want to choose flags, GPU split or tiles yourself | IaaS (remote workstation) | You run husk in a terminal on the machine and change the command any time |
| Scene needs a specific Houdini build or a third-party delegate | IaaS | You install the exact versions you tested |
| You want to compare one process vs one per GPU | IaaS | You can run both tests on the same server and read the logs |
| Short one-off sequence, standard settings | SaaS | No setup; you pay per job |
Rule of thumb: if the default ROP settings are fine, a managed farm is the least work. If you rely on custom husk flags, environment variables or a per-GPU split, a machine you control lets you run exactly the command you tested.
Running a husk job 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, then run husk exactly as on your desk:
- Upload the project with the USD files, textures and caches through iRender Drive, keeping relative paths.
- 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 and driver versions. The Karma XPU kernels compile on the first render; you can also pre-compile them from the Render menu (the full set can take hours, and the cache stays on your saved server image).
- Render one frame with your husk command and check the device list and elapsed time in the log.
- Start the full range, either as one process or one per GPU, with
--skip-existing-framesso a restart picks up where it stopped.
husk job checklist
Use this as a final check before you start the full range on any machine.
Frequently asked questions
1. Does husk need a Houdini license?
According to SideFX, husk only checks that a Houdini license exists. Rendering with Karma CPU or XPU checks out a Karma license, and Python callbacks run by husk check out an Engine license while they run.
2. Can I choose which GPU husk uses?
husk has no GPU flag. Use Karma XPU environment variables such as KARMA_XPU_DEVICES, or the CUDA variable CUDA_VISIBLE_DEVICES, before starting each process.
3. Do several GPUs combine their memory in Karma XPU?
No. SideFX states that each GPU is addressed separately and memory is not pooled, so every card must hold the scene.
4. How do I resume a sequence after a crash?
Run the same command with –skip-existing-frames. husk skips frames that already have files on disk for all render products.
5. Is one husk process per GPU faster than one process for all GPUs?
It depends on the scene. Four processes render four frames at once but load the stage four times. Test both on a few frames and compare the elapsed times in the logs.
6. How do I render a huge still on several machines?
Use –tile-count and –tile-index to render tiles separately, stitch them with itilestitch and denoise the stitched image with idenoise.
7. Can husk render only part of a frame range?
Yes. Use -f for the start frame and -n for the number of frames, or –frame-list with an exact list of frames.
8. How do I watch a long husk frame before it finishes?
Add –snapshot with a number of seconds; husk saves a partial image at that interval. On Linux, sending SIGUSR1 to the process writes one on demand.
9. Can I stop a Karma frame early at a fixed quality?
In Houdini 22, –karma-percent-of-samples stops a Karma render at a percentage of its samples.
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: husk, Inside husk, Karma XPU, USD Render ROP, husk licenses (SideFX FAQ), What’s new in Houdini 22: Karma, NVIDIA CUDA environment variables. 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).


