Ever watched a dazzling fireworks display and wondered how it’s done in Houdini? Do complex node networks and particle systems leave you confused?
As a beginner, you might feel overwhelmed setting up pyro simulations or fine-tuning color and timing for a convincing fireworks explosion. Tutorials often skip vital details, making you hit dead ends.
This article guides you through a clear workflow to build a vibrant fireworks effect in Houdini for your New Year ads. You won’t need advanced scripting or years of experience.
By the end, you’ll understand each stage—from sourcing particles and lighting the explosion to rendering settings—so you can craft your own festive animation without guesswork.
What pre-production decisions should I make for a New Year fireworks ad?
Before jumping into Houdini, establish your creative and technical foundation. Sketch the visual style—realistic bursts or stylized trails—and gather reference videos for timing, color, and fragmentation. Define aspect ratio (16:9, 9:16) and frame rate (24, 30, 60fps) to match your delivery platform. Early clarity here avoids rework during heavy simulation passes.
- Concept and storyboard: frame composition, camera moves, burst timing.
- Technical specs: resolution, color space (linear EXR), bit depth.
- Simulation scope: particle count, pyro voxel size, GPU vs CPU budget.
- Cache strategy: .bgeo.sc naming convention, disk location, versioning.
- Render pipeline: Mantra or Redshift, required AOVs (beauty, depth, velocity).
Also plan for post-production. Decide necessary passes (smoke, glow, sparks), and ensure your file structure supports easy compositing. Allocate time for iteration—low-res tests first—so when you simulate the full-resolution fireworks for your New Year ads, the workflow stays efficient and predictable.
How do I set up a Houdini project, scene scale, and camera for a fireworks shot?
Recommended project settings (FPS, resolution, scene scale)
Before you animate any pyro simulation, define your FPS, resolution, and scene scale. For cinema-quality visuals, 24 or 25 FPS is standard. Advertising may demand higher frame rates—30 FPS or 48 FPS—for smooth slow-motion retimes. Set your output resolution in the Render Settings to match final deliverables: 1920×1080 for HD, 3840×2160 for 4K. Consistent resolution ensures predictable render times.
Scene scale in Houdini defaults to meters, which aligns with most physics solvers. Fireworks shells and bursts behave according to gravity and buoyancy settings, so use a 1-unit = 1 meter scale. In the /obj level, create a grid or sphere as a reference of known size (1 m diameter). This helps you visualize burst radius and emitter position. Proper scale ensures realistic velocity falloff and collision detection.
Folder structure, asset naming conventions, and scene templates
Organizing your project prevents confusion when dealing with multiple shots or iterations. Create a root folder named after the project:
- project_root/
- ├─ assets/
- ├─ scenes/
- ├─ simulations/
- ├─ renders/
- └─ docs/
Within assets, separate geometry (geo), shaders, and textures. Use a consistent naming pattern: fwk_shell_geo_v001.hip, fwk_burst_shader_v002, fwk_smoke_sim_v003. Increment version numbers on each major change.
Create a base scene template in scenes/template_fireworks.hip that includes a default camera, environment lights, and viewport presets. Your template should assign a pre-configured camera node with focal length (50 mm), aperture, and clipping planes (near 0.1 m, far 1000 m). This ensures every shot starts with the same visual frame and reduces setup time.
How do I create and emit particle shells that define the firework burst?
Starter node network (source geometry → POP Network → DOP import)
Begin by creating a simple emitter geometry, such as a sphere or grid of points representing individual shells. Dive into its SOP context and wire in a POP Network. Inside the POP Network, add a POP Source set to “All Points” with impulse emission on frame 1. This ensures a single burst.
- Source Geometry: sphere or scattered points
- POP Network: handles particle simulation
- DOP Import: brings simulated points back to SOP
Use a DOP Import node in the parent SOP to fetch the particle data, selecting the appropriate simulation object from the dropdown. Set “Import Style” to Points to preserve attributes for shading and instancing.
Key particle attributes to set (velocity, life, color, id) and why they matter
Defining core attributes at emission tailors the explosion look and behavior:
- velocity: Control radial speed. Use an expression like normalize(@P) * rand(@id) * speedFactor for varied bursts.
- life: Determines how long each shell remains visible. A short life creates a tight blast, longer life yields trailing sparks.
- color: Assign per-particle color via rand(@id) mapped through a ramp parameter. Essential for multi-hued fireworks.
- id: Unique identifier for each particle. Drives consistent coloring, noise offsets, or deferred spawning of sub-particles.
By authoring these attributes in a SOP-level Wrangle just after POP Import, you maintain a procedural pipeline. Downstream nodes—like Copy and Instance or Trail SOPs—will read these attributes to drive geometry, lighting, and motion blur without manual adjustments.
How do I drive a pyro simulation to turn particle shells into an explosive burst?
Begin by animating a particle shell in a POP Network, ensuring particles emit uniformly on a sphere or custom geometry. Use simple radial velocity (@v) or copy an @N attribute from the source surface. This shell acts like a detonator shape for your fireball. Adjust lifespan and velocity ramp so that particles slow slightly before the burst, defining the explosion timing.
Convert particles to volumes with a Volume Rasterize Particles SOP. Set “Particle Radius Scale” to control smoothness, then output a density volume. You can also bake a temperature or fuel attribute on particles (e.g. @fuel=1) and rasterize both into separate fields. These volumes become your pyro sources and define the initial fire distribution.
Inside a DOP Network, use a Source Volume DOP to inject density, temperature, and fuel into the pyro solver. Chain a Gas Configure Explosion to auto-set buoyancy, combustion and expansion parameters. Increase the “Buoyancy Scale” for a rapid vertical push, and tweak “Combustion Rate” to control how fast the fireball burns.
To replicate the particle shell’s outward motion, drive the pyro velocity field from your particle normals. In the Source Volume’s “Velocity Field Source,” assign the @N attribute so gas inherits the shell’s radial direction. Then add a Gas Turbulence DOP with low-frequency noise to break symmetry—this keeps the core shape but adds natural eddies.
Control the precise frame of ignition by animating the Source Volume’s “Operation” switch or stamping an activation attribute in SOPs. A brief, high-intensity injection (2–4 frames) yields a crisp explosion rather than a slow burn. Finally, attach a Gas Resize Fluid Dynamic DOP set to “Non-Uniform” so the pyro bounds expand with the fireball, preventing any clipping as the burst grows.
How should I shade, light, and render the fireworks for crisp, ad-ready visuals?
Achieving crisp, ad-ready visuals starts at the shading stage. Rather than using a flat emission, assign Houdini’s Pyro Shader to the simulation. This shader lets you control emission intensity, scattering and absorption in a single node. Use a temperature ramp to map heat values to color, then plug density into scattering weight. This ensures hotter cores glow intensely while outer tendrils fade naturally.
For additional detail, dive into a Volume VOP subnetwork. Sample a low-frequency noise field to modulate density and emission separately. By blending two noise frequencies—one for broad shapes, one for fine flickers—you break up uniformity and mimic real explosive patterns. Always preview in the Render View so you see how shader settings interact with lighting.
Lighting is equally critical. Start with an HDRI dome for ambient bounce and realistic reflections on nearby objects. Add a high-intensity key light colored slightly warm to accentuate the glow. Position a cooler fill light opposite the key to reveal volume edges without washing out core brilliance. Finally, a subtle rim light—blue or purple—can outline sparks against a night sky.
- Use an HDRI dome at low intensity (0.2–0.5) for environment fill.
- Key light: area light with temperature around 3000 K, intensity tuned to 2× background.
- Fill light: cooler (5500 K) at half key intensity to reveal volume structure.
- Thin rim light: point or distant light with colored gel for accent.
When rendering, choose Karma XPU or Mantra with volume‐optimized settings. Set Volume Step Size to 0.1–0.3 of your voxel size to balance detail and speed. Increase Pixel Samples (e.g., 4×4 or 6×6) to reduce grain in low-light areas. Enable motion blur at the object level to capture fast-moving sparks. Finally, export multichannel EXRs with separate AOVs for emission, depth, and color—this gives post teams full control over glow, contrast, and compositing layers.
By combining a tailored shading network, a balanced lighting rig, and optimized render settings, your fireworks will pop off the screen with crisp detail and cinematic polish.
How do I composite, time the burst for impact, and export master assets for delivery?
Once your fireworks explosion sim is cached and lit, the next step is to integrate all passes, dial in the peak of the burst, and prepare clean deliverables. In Houdini you’ll leverage ROP nodes for multilayer exports, SOP-level time controls to sync your explosion, and a consistent linear color pipeline for compositing.
First, render separate AOVs (albedo, emission, depth, motion vectors) using a Mantra or Karma ROP. This separation lets you adjust glow intensity, color grading, and depth-based fog in post without re-rendering. Enable deep EXR output if you need pixel-accurate Z-contours for realistic depth-of-field or volumetric holdouts.
To hit the burst at just the right moment, use a Time Shift SOP ahead of your ROP Output. Offset the frame on your pyrocache so the apex of the explosion lands on your desired keyframe. If you need variable speed or slow-mo, insert a CHOP network: import your frame channel, apply a speed control filter, and export back to a Time Warp SOP. This procedural timing ensures your explosion never feels “off-beat.”
In compositing (Nuke or Houdini’s COPs), assemble your EXR layers in a linear color space. Apply a glow pass to the emission AOV, then use the depth AOV to grade atmospheric fades. Key your motion vectors for optional motion blur, giving your burst extra energy. Use mask channels from the simulation to isolate sparks or smoke for targeted color tweaks.
Finally, package your master assets with a ROP Output Driver set to multichannel EXR. Provide these elements:
- Beauty EXR (combined fire, smoke, sparks)
- Individual AOVs (emission, depth, motion, albedo)
- Simulation cache (packed Bgeo or Alembic for 3D integration)
- Timecode reference frame sheet and any CHOP timing curves
Delivering this organized set of master assets ensures that any downstream editor or VFX artist can seamlessly integrate your fireworks into a New Year ad, adjust timing for cut, and refine colors or effects without going back to the sim phase.