Solaris Point Instancing for Karma XPU: Millions of Copies, One GPU Budget
How you build copies in Solaris decides how big the USD stage gets and what every GPU has to hold. The short version:
- Method: Point Instancer for large scatters; Reference makes a full prim per copy
- XPU: nested instancing and per-instance properties are supported
- Memory: prototypes once, point arrays per instance, on every GPU
- Attributes: copy only the point attributes you use in shading
- Render-time: Scatter Instances LOP builds instances in Hydra; no motion blur on animated sources
Forests, cities, debris fields and set dressing are mostly copies of a few assets. Rendered as separate geometry, they fill GPU memory long before the image looks dense; rendered as instances, a single prototype can appear millions of times. In Solaris, the Instancer LOP offers several ways to build those copies, and they behave very differently in stage size and memory.
This guide compares the instancing methods, explains what Karma XPU supports and what an instanced scene costs on each GPU, and covers render-time scattering, Cryptomatte for instances and the checks to run before a farm render.
Checked against the SideFX Houdini 22 documentation (Instancer LOP, Point instancing, Scatter instances, Karma XPU, What’s new in Karma 21 and 22), November 2026.
Reference, instanceable reference or point instancer
The Instancer LOP’s Method parameter decides what ends up on the USD stage. Reference creates a separate prim at each point that references the prototype; SideFX notes these take up more storage space than instanceable prims. Instanceable Reference also creates a prim per point, but the copies share a hidden copy of their descendants, which cannot be edited per copy. Point Instancer creates a single prim with the prototypes as children and draws the copies on demand in the viewer or renderer.
For scatters of thousands of copies and more, the point instancer keeps the stage smallest and the viewport most responsive. Use references only when each copy needs its own edits, and instanceable references when you want a prim per copy without per-copy overrides. The Inherit and Specialize variants behave like their Reference counterparts but change how the copies relate to the source prim.
Sources: Instancer LOP.
What an instanced scene costs on each GPU
The Karma XPU page lists nested instancing, including per-instance properties, as supported, with no instancing limitations. Memory still follows the usual XPU rule: memory is not pooled, so every GPU holds the prototypes and the instance data. On a 4x RTX 5090 server that means the scene must fit in 32 GB, not in 128 GB.
Prototype geometry is stored once per prototype, so the instance count mostly grows the point arrays and any primvars you copy to instances. The Point Attributes to Copy parameter controls this: for point instancers, an array primvar is created for each listed attribute. Copy only what the shaders or Cryptomatte read. On the Instancer LOP, Only Copy Specified Prototype Prims (on by default) can also give a smaller stage.
Two engine changes help instanced scenes. Houdini 21 added data deduplication to Karma XPU, which reduces memory when identical geometry or primvars appear in a scene, and Houdini 22 reduces memory for subdivided meshes by up to half. Subdivided prototypes are worth checking: dicing every copy of a subdivided rock costs far more than the base mesh.
Sources: Karma XPU, Instancer LOP, What’s new in Houdini 21: Karma, What’s new in Houdini 22: Karma.
Solaris instancing tools at a glance
Solaris instancing tools and when to use them
From the Houdini 22 LOP node help.
| Tool | What it does | Use it for |
|---|---|---|
| Instancer LOP (Point Instancer) | One prim with prototypes as children; copies drawn at render time | Large scatters: forests, rocks, crowds of props |
| Instancer LOP (Instanceable Reference) | One prim per point sharing a hidden copy | Fewer copies that need their own prim, without per-copy edits |
| Scatter Instances LOP | Creates instances at render time through Hydra | Very dense scatters you only need to see in the render |
| Edit / Assign Prototypes LOP | Changes prototypes in place or swaps the prototype of chosen instances | Variations without rebuilding the instancer |
| Merge / Split Point Instancers LOP | Combines instancers or splits one by prototype or attribute | Organising instancers for layout, render passes or Cryptomatte |
Point instancers can also be edited by other point instancers, which SideFX calls one of their strongest features: you can thin, move or replace instances downstream without touching the original scatter. Keep the instancer and its prototypes in the same project folder so the scene opens on another machine with every prototype found.
Sources: Point instancing, Assign Prototypes, Split Point Instancers.
Render-time scattering with Scatter Instances
The Scatter Instances LOP takes a different approach and creates instances directly at render time through Hydra. In its Deferred mode, the positions and orientations arrays on the stage stay empty because they are calculated during the render, which keeps the stage small. Nothing appears in the viewport until Karma or Storm is running, although a preview mode works with the Vulkan viewport.
Know the limits before you rely on it for a sequence: SideFX marks support for animated source geometry as beta because motion blur is not supported, and notes that the relaxation step can fail when the number of instances is very large. For moving cameras over static scatters it works well; for animated scatters with motion blur, use a regular point instancer.
Sources: Scatter instances.
The trade-off is visibility: what you save on the stage you pay in previews, because the instances only exist once a Hydra renderer is running.
Cryptomatte and per-instance variation
Compositors usually need mattes per asset or per instance. Karma builds Cryptomatte IDs from prims, from materials bound to prims, and from constant or uniform string or integer primvars. For point instances, SideFX recommends assigning a unique value of a string primvar to each instance and pointing the Cryptomatte render var at it; material stylesheets are then not needed.
Per-instance colour or texture variation works the same way: copy one attribute to the instances and read it in the shader. Each copied attribute is another array on every GPU, so pick one variation attribute rather than several. Our Karma AOV and Cryptomatte guide covers the render var setup.
Sources: Cryptomatte and material AOVs in Karma.
SaaS or IaaS render farm for heavily instanced scenes?
Which farm type fits an instanced scene
Both render instances; they differ in how easily you can check memory on the target GPU.
| Situation | Usually a better fit | Why |
|---|---|---|
| Scatter tested on XPU, comfortably inside 32 GB | SaaS (managed farm) | Upload and submit |
| Scene close to the VRAM limit | IaaS with 32 GB cards | You watch per-GPU memory and trim attributes or subdivision before the full run |
| Render-time scatters (Scatter Instances LOP) | IaaS (remote workstation) | You check the deferred instances render as expected on the target machine |
| Large asset library referenced by many shots | IaaS | Assets stay on the machine between sessions |
| Small one-off render | SaaS | No setup time |
Rule of thumb: once the scatter renders on XPU and fits on one card, a managed farm is the least work. While you are still trimming memory or testing render-time scatters, a machine you control lets you fix it on the spot.
Rendering instanced scenes on an iRender server
On iRender you rent a whole Windows workstation with your own Houdini, so prototypes, instancers and caches load exactly as on your desk:
- Upload the project, including every prototype asset, through iRender Drive with 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 build. The Karma XPU kernels compile on the first render and the cache stays on your saved server image.
- Render the densest frame and check per-GPU memory and the device list in the render stats.
- Render the range with husk or the USD Render ROP.
Instancing checklist
Use this as a final check before you start the full range on any machine.
Frequently asked questions
1. What is the most memory-efficient way to instance in Solaris?
Use the Instancer LOP with Method set to Point Instancer. It creates one prim with the prototypes as children and draws the copies at render time.
2. Does Karma XPU support nested instancing?
Yes. The Karma XPU page lists nested instancing, including per-instance properties, as supported.
3. Do instances share GPU memory across several GPUs?
No. Karma XPU memory is not pooled, so every GPU holds the prototypes and instance data.
4. What makes an instanced scene use more memory?
Mainly the number of instances times the attributes copied to them, plus subdivided prototypes. Copy only the attributes you use.
5. Can Scatter Instances render motion blur?
Not on animated source geometry. SideFX marks that support as beta because motion blur is not supported.
6. How do I get a Cryptomatte per instance?
Assign a unique string primvar value to each instance and use that primvar as the Cryptomatte source.
7. What is the difference between Instanceable Reference and Point Instancer?
Instanceable Reference creates one prim per point sharing a hidden copy; Point Instancer creates a single prim with the prototypes as children and draws copies at render time.
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: Instancer LOP, Point instancing, Scatter instances, Karma XPU, Cryptomatte and material AOVs in Karma, 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).


