Are you ready to dive into the world of 3D effects with Houdini but feel lost among its licensing tiers?
As a beginner, you might wonder if Houdini Apprentice offers enough features or if you need to invest in Houdini Indie or Houdini Core.
Confusion over pricing limits and feature sets can stall your learning curve and drain your budget before you’ve created your first simulation.
By examining the strengths, restrictions and ideal use cases of each license, this guide will help you zero in on the version that matches your goals and skill level.
What are the core differences between Houdini Apprentice, Indie, and Core?
Feature & technical limits snapshot (file formats, render/export, resolution)
Houdini Apprentice, Indie, and Core share the same node-based workflows and VEX engine but impose different limits. Apprentice is free for non-commercial learning: it caps renders at HD (1280×720), adds a watermark, and restricts export formats (.bgeo, .rat). Indie removes watermarks, supports exports to FBX, Alembic, USD, and allows up to 4K resolutions with GPU-accelerated Mantra and Karma. Core offers unlimited resolution, all formats, farm rendering, PDG/LOPs, and full Python API.
| Feature | Apprentice | Indie | Core |
|---|---|---|---|
| Commercial use | No | Yes, <$100k/yr | Yes, unlimited |
| Max output resolution | 1280×720 | Up to 4K | Unlimited |
| Watermark | Yes | No | No |
| FBX/Alembic/USD export | Import only | Full export | Full export |
| GPU acceleration | No | Yes | Yes |
| Farm & distributed ROP | No | Limited | Full |
| PDG & Solaris USD LOPs | No | Limited | Full |
Licensing & cost summary (free vs paid, revenue and usage caps)
Each license aligns with specific budget and project scale:
- Apprentice: Free, for learning only. No commercial output allowed, ideal for students and hobbyists.
- Indie: Subscription or perpetual, around $269/yr. Permits commercial work under $100k gross revenue per year, single-seat license.
- Core: Annual subscription ~$4,500. Unlimited commercial use, includes support and farm licenses.
Choosing depends on your pipeline needs: start with Apprentice to master node-based workflows; upgrade to Indie when you enter commercial production within revenue limits; move to Core when you require full integration, distributed rendering, and advanced USD-based scene assembly.
Can I use Apprentice, Indie, or Core for learning, building a portfolio, or presenting work to clients?
All three Houdini licenses share the same procedural workflows—nodes, attributes, VEX snippets and digital assets—so you’ll learn transferable skills whether you choose Apprentice, Indie or Core. The main differences lie in output restrictions and commercial usage rights.
- Apprentice: Ideal for learning and experimenting. Renders are watermarked and capped at 1280×720. Not licensed for revenue-generating projects, so it’s best for student reels or proof-of-concepts.
- Indie: Allows commercial use on projects earning under $100K per year. No watermarks, resolution up to 4K, and full access to most renderers (Mantra, Karma, Redshift). Great for building a professional portfolio and delivering client previews.
- Core: No output limits or revenue caps. Use it for any client work—feature-film VFX, high-res advertising, or interactive installation. Provides full support, HDAs, Solaris, PDG and more.
For a demo reel or personal site, Apprentice is often enough, but expect watermarks on final frames. As soon as you need polished, client-ready renders—especially in UHD or when charging fees—upgrading to Indie removes watermarks and raises resolution ceilings. If your business grows beyond the revenue cap or demands studio-grade toolsets like multi-GPU rendering, switch to Core for unrestricted production.
Which license allows commercial work — what are the revenue, usage and distribution limits for Indie vs Core?
Both Indie and Core licenses permit commercial output, but SideFX enforces a yearly revenue cap and usage constraints on Indie. Understanding these limits helps small studios decide if the $269/yr Indie license covers their current needs or if they require full commercial flexibility of Core.
| Limit | Indie | Core |
|---|---|---|
| Annual Revenue | Up to $100,000 gross | No cap |
| Render Resolution | Up to 4K per frame (8192×8192) | Unlimited |
| Distribution & Sharing | Final renders only; no .hip or HDAs | Full project files and HDAs |
| Network Rendering | Single-machine only | Farm and cloud pools allowed |
For teams earning under $100k and rendering scenes up to 4K on a single workstation, the Indie license delivers full Houdini procedural workflows. Studios exceeding revenue caps, needing farm rendering, or sharing HDAs commercially must upgrade to Core.
How do technical restrictions (rendering, HDAs, third-party plugins, performance) affect real projects?
When building a pipeline for film, VFX or game cinematics, each Houdini license tier imposes trade-offs that ripple through production. Understanding how rendering, HDAs, plugins and overall performance differ between Houdini Apprentice, Indie and Core is critical before you commit to a project budget or deadline.
Rendering limits can become bottlenecks under tight schedules. Apprentice adds watermarks, caps output resolution and forbids farm rendering—only local Mantra or Karma with limited threads. Indie allows non-watermarked frames up to 4K and two farm nodes but blocks some GPU renderers. Core has no watermarks, full farm support and unlimited renderer integration.
Digital Asset (HDA) usage also shifts with your license. Apprentice can create and test HDAs but cannot publish them commercially or load licensed Locked HDAs from studios. Indie lets you build shareable HDAs for small teams yet cannot open assets requiring a Core license. Core grants full authoring and loading privileges, essential for large pipeline toolsets.
Third-party plugin support can decide whether you stick with Mantra or switch to Redshift, Arnold or Octane. Only Core smoothly integrates most render engines and GPU libraries. Indie excludes some vendor SDKs and limits scriptable API calls. Typical plugin scenarios:
- Redshift: available in Core, limited or unsupported on Indie/Apprentice
- OpenVDB-based volumetrics: full feature set in Core, partial in Indie
- Custom C++ SOPs: Core lets you compile and load, Indie only Python HDAs
Performance caps influence simulation speed and iterations. Apprentice uses up to four CPU cores and no PDG/guided scheduling. Indie unlocks eight cores and basic PDG but restricts GPU acceleration for Solaris or Karma XPU. Core removes thread limits, leverages hybrid CPU-GPU solvers and scales across render farms for complex FLIP fluids or Pyro volumes.
In practice, commercial projects need predictable throughput. Indie suits solo artists or small studios working under 4K deliverables. Core becomes indispensable when you require advanced plugins, full HDA pipelines, high-throughput rendering and unbounded compute resources. Mapping license boundaries to your deliverable schedule ensures you avoid costly mid-project upgrades.
Which license is the best fit for my situation: student/hobbyist, freelancer/indie dev, small studio, or enterprise?
Matching your project requirements to the right SideFX license saves costs and unlocks essential features. Evaluate your budget, revenue, team size, and rendering scale before choosing Houdini Apprentice, Houdini Indie, or Houdini Core.
Student / Hobbyist
- Cost: Free non-commercial license
- Render limits: 720p resolution with a small Houdini logo
- Feature set: Full procedural SOPs, VEX, DOPs, digital asset creation
Why? As a learner, you get the complete node-based workflow, SOP networks, and simple VEX scripting without worrying about revenue caps. The watermark and resolution limit don’t hinder skill building.
Freelancer / Indie Developer
- Cost: US$269/year or US$24/month
- Revenue cap: US$100,000/year
- Technical: 4K renders, full Solaris LOPs, Karma, KineFX, 8-core CPU limit
Why? You gain commercial rights, higher resolution outputs, and advanced tools like Solaris for USD layout and PDG for simple task distribution. The core-count limit fits a one-to-two-machine pipeline without a large farm.
Small Studio
- License: Houdini Core per seat
- Features: Unlimited cores, HQueue distributed rendering, PDG farm management
- Scalability: Floating licenses, multi-seat network use
Why? With multiple artists, you need floating Core seats for Houdini Engine integration in Maya or Unreal, full PDG orchestration, and Solaris-driven lookdev on a render farm.
Enterprise
- License: Volume Core licenses with discounts
- Support: Premium SideFX support, custom training, early access beta
- Integration: Custom pipeline hooks, Houdini Engine SDK
Why? Large teams require robust pipeline automation, unlimited node count, advanced USD workflows and render farm management. Premium support ensures fast issue resolution and seamless enterprise integration.
How do I test, upgrade, or migrate licenses and keep projects compatible in a production pipeline?
Begin by setting up a local license server or using hserver and hkey tools to swap between Houdini Apprentice, Indie, and Core tokens. Point HOUDINI_LICENSE to different license files or servers, then launch Houdini in command-line mode (hython or houdini -nobreakpoints) to verify that each project opens without errors or missing nodes.
When you upgrade from one license tier to another, track the Houdini version carefully. Save your .hip files using “File → Save As…” and select the earliest compatible version if teammates still run an older build. For Houdini Digital Assets, set the “Compatibility” tab inside the Type Properties and bump the version only after testing all input/output connectors under both license levels.
- Maintain a branch in your version control for each license tier to isolate feature tests.
- Automate nightly CI builds that load assets via HDK or Houdini Engine to catch missing nodes or licensing errors.
- Use environment modules (HOUDINI_DSO_PATH, HIPLOADPATH) to point to separate toolsets for Indie/Core development.
In a mixed-license studio, designate a build machine with Core for heavy simulations (PDG, KineFX pipelines) and an Indie node for smaller shots. Document which assets rely on Core-only features in your asset library. Finally, always run a “render smoke test” on each tier—export a headerless image sequence or .bgeo.sc—to confirm that ROP outputs and caching behave identically across your pipeline.
