November 18, 2026 Maddie Quach

Houdini husk Command-Line Rendering: Frame Ranges, Tiles and 4 GPUs

huskRender USD from the command line
From SideFX documentation

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.

iRender
From a LOP Network to Pixels: Where husk Sits
Schematic
LOP networkin HoudiniUSD Render ROPor TOPs USD Rendershot.usdtemp or saved filehuskloads the USDKarma XPUother delegaterender productsEXR files from the USD render settingsLicences (SideFX FAQ)husk itself: checks a Houdini licence exists, does not check one outKarma delegate: Karma licence · Python callbacks: Engine licenceEverything right of the USD file can run on another machine without opening Houdini.
Houdini sidehusk sidelicences
Schematic based on SideFX husk docs and licensing FAQ

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.

Referencehusk flags

The husk options a farm job actually uses

Every flag below is listed on the Houdini 22 husk page.

FlagWhat it doesWhen you need it
-f / -n / -iStart frame, number of frames (start included), frame incrementEvery sequence job; -i lets several processes share one range
--frame-listSpace-separated list of frames; overrides -f, -n and -iRe-rendering a handful of bad frames
-o / --make-output-pathOutput path; create missing foldersFresh output folders on a new machine
--skip-existing-framesSkips frames whose render products already exist on diskRestarting a job after a crash or a reboot
--engine xpu|cpuOverrides the Karma engineForcing XPU even if the USD says CPU
-s / -c / -r / -pRender settings prim, camera, resolution, pixel samplesOverriding what is stored in the USD file
-V levelVerbosity 0–9; add e for elapsed time, t for timestamps, a for Alfred-style progressLogs you can read the next morning
--timelimit / --snapshotCancel after N seconds; save a partial image every N secondsPreviews and long frames you want to watch
Note: husk has no flag to pick a GPU; device choice comes from environment variables, shown below.

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.

iRender
Render a frame range with husk
shell
1husk --engine xpu -f 1001 -n 100 \
2 -s /Render/rendersettings -c /cameras/shotcam \
3 --skip-existing-frames --make-output-path \
4 -V 2e -o "D:/proj/render/shot.$F4.exr" \
5 "D:/proj/usd/shot.usd"
One process, every GPU the machine exposesFlags: SideFX husk docs (Houdini 22)

-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.

iRender
Two Ways to Use a 4-GPU Server With husk
Schematic
A. One husk process, all GPUsB. One husk process per GPUhusk shot.usd 1001–1100stage loaded once in RAMGPU 0full sceneGPU 1full sceneGPU 2full sceneGPU 3full sceneall 4 GPUs share each frame, one by oneRAM: 1 copy of the stagehusk 0every 4th frameown stageGPU 0frames 1001…husk 1every 4th frameown stageGPU 1frames 1002…husk 2every 4th frameown stageGPU 2frames 1003…husk 3every 4th frameown stageGPU 3frames 1004…4 frames render at the same timeRAM: 4 copies of the stage
husk processGPU (memory not pooled)RAM cost
Schematic based on SideFX husk and Karma XPU docs

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.

iRender
One husk process per GPU (Windows)
batch
1@echo off
2rem launch_4gpu.bat: one husk per GPU
3for /L %%G in (0,1,3) do (
4 start "gpu%%G" cmd /c render_gpu.bat %%G
5)
6
7rem render_gpu.bat: GPU index arrives as %1
8set CUDA_VISIBLE_DEVICES=%1
9set KARMA_XPU_DISABLE_EMBREE_DEVICE=1
10set /a F=1001+%1
11husk --engine xpu -f %F% -n 25 -i 4 ^
12 --skip-existing-frames --make-output-path ^
13 -o "D:/proj/render/shot.$F4.exr" ^
14 "D:/proj/usd/shot.usd" > "D:/proj/logs/gpu%1.log" 2>&1
GPU 0 renders 1001, 1005 … 1097; GPU 3 renders 1004 … 1100husk: SideFX docs · CUDA_VISIBLE_DEVICES: NVIDIA CUDA docs

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.

iRender
Rendering One Large Frame as Tiles
Schematic
Still split with --tile-count 4 301234567891011--tile-index 5 renders this tile only12 tile filesone per machineor one per GPUitilestitchships in Houdini binidenoiseon the stitched imageDenoise after stitching: per-tile denoising can leave seams.
command-line toolintermediate files
Schematic based on SideFX “Inside husk”

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.

iRender
Render one tile of a large still
batch
1rem tile 5 of a 4 x 3 grid, one frame
2husk --engine xpu -f 1001 -n 1 ^
3 --tile-count 4 3 --tile-index 5 ^
4 -o "D:/proj/render/still.$F4.exr" ^
5 "D:/proj/usd/still.usd"
Tile indices start at 0; stitch the files with itilestitchSideFX husk and “Inside husk” docs

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: -V takes 0–9, plus e for elapsed time, t for timestamps and a for Alfred-style progress that many queue managers parse.
  • Snapshots: --snapshot 300 saves 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: --timelimit cancels the render after N seconds; --timelimit-image applies the limit to each image instead of the whole sequence.
  • New in Houdini 22: --karma-percent-of-samples stops a Karma render at a percentage of its samples, --enable-usd-errors shows USD warnings that are normally hidden, and --error-summary was 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?

CompareNeutral guide

Which farm type fits a husk workflow

Both can render USD with husk; they differ in who writes and runs the command.

SituationUsually a better fitWhy
You submit a .hip or .usd and want frames backSaaS (managed farm)The farm builds the husk command and queue for you
You want to choose flags, GPU split or tiles yourselfIaaS (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 delegateIaaSYou install the exact versions you tested
You want to compare one process vs one per GPUIaaSYou can run both tests on the same server and read the logs
Short one-off sequence, standard settingsSaaSNo 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

iRender
How iRender works: your computer controls your own multi-GPU server
IaaS render farm
Your PC or MacNo powerful GPU neededRemote desktopLive screen1:1 like your PCYOUR OWN GPU SERVERbare-metal · not sharedGPUGPUGPUGPUGPUGPUGPUGPU1, 2, 4 or 8 × RTX 5090 (32 GB) or RTX 4090 (24 GB)Threadripper PRO · 256 GB ECC RAM · 2 TB NVMe SSDFull admin access · your setup is saved between sessions1Register, top upFirst $50+ top-up doubled2Upload your projectiRender Drive, free3Start and connectRemote desktop, any OS4Render, shut downBilling stops, per minute✓ Your workstation, just more GPUs: no queue to wait, no farm plugin, no job submission, no settings changed
Your mouse and keyboardServer screen streamed back
Schematic, not to scale

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:

  1. Upload the project with the USD files, textures and caches through iRender Drive, keeping relative paths.
  2. 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.
  3. 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).
  4. Render one frame with your husk command and check the device list and elapsed time in the log.
  5. Start the full range, either as one process or one per GPU, with --skip-existing-frames so 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.

Checklisthusk job checklist
0 / 7 done
Tip: tick each item as you set up the job; the ticks reset when the page reloads.

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.

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).

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:
, , ,

Maddie Quach

Maddie Quach, from iRender's customer support team, has written more than 100 articles for the iRender blog on Maya, Houdini, Arnold, Karma XPU and Redshift.
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
이 페이지는 한국어로도 제공됩니다. 한국어로 보기 →