ANR 2D fire smoke sim
Fire and smoke from any roto or alpha, simulated in 2D and shaded as a lit, premultiplied element ready to merge over the plate.
- Simulations
- Simulations pack
- 2 inputs
- 131 controls
Overview
The node turns the alpha of its Source into an emitter and simulates fire and smoke rising from it, frame by frame, on a 2D grid the size of your image or a percentage of it. Fuel burns where it is hot and makes flames and soot; the hot gas rises, swirls and breaks up into licks and billows. The result is shaded like a lit volume: blackbody flames, smoke with self-shadowing and rim light, and light from the fire on the smoke.
Use it for torches, burning objects, flames along an edge, smoke plumes, chimney smoke and steam: anything seen from the front, where a 2D simulation reads well. Roto or paint the burning area, connect it and play forward. A Collision alpha blocks the flow, for a wall or an object the smoke has to go around.
The tabs follow the order you work in. Emission sets what the emitter adds each frame, Turbulence and Shape set how the gas moves and breaks up, Shading sets the look and never re-simulates, and Sim holds the grid, the walls and the cache. The simulation lives in the node: playing forward costs one step per frame, scrubbing back restarts from the nearest memory snapshot, and an edit to the roto upstream is noticed and re-simulated by itself.
For a finished shot, build a disk cache: the node then plays the saved frames, opens instantly with the script and never re-simulates. Bullet Time holds the simulation on one frame, for frozen-moment shots.
Inputs
- Sourcerequired
The emitter: a roto, a key or any image. Its alpha (or the channel chosen in emit from) says where fire and smoke are born, from 0 (nothing) to 1 (full emission). Animate it and the fire follows.
- Collisionoptional
Optional solid shapes. Where its alpha is solid, the flow is blocked and goes around it, like a wall, a ceiling or an object in the way.
Output. Premultiplied fire and smoke over transparent black, ready to merge over the plate (or tick over source to see it over the Source image). output can also show fire or smoke alone, the raw simulation fields, velocity, the emitter, normals or a lighting pass; render layers adds the passes as extra channels.
Quick start
- Make the emitter: a Roto, a key or a painted alpha where the fire should start. Connect it to Source.
- Add ANR 2D fire smoke sim and view it. On the Sim tab check start frame: the simulation starts empty on that frame.
- Play forward from the start frame. The fire builds up frame by frame; going back re-simulates from the nearest snapshot.
- Set the amounts on Emission: fuel and temperature for flames, smoke for pure smoke. emit velocity y and velocity jitter shape the flame tongues.
- Shape the motion on Turbulence (buoyancy, wind, turbulence) and on Shape (shredding and disturbance for licks and cauliflower edges).
- Grade the look on Shading: fire intensity and colour temperature, smoke colour and lighting. These changes do not re-simulate.
- Merge the result over the plate.
- When the motion is right, set a cache folder in Sim > Cache (or click Generate Autofill), turn off proxy and press build / rebuild cache. read cache turns on and the shot plays from disk.
The panel
The node's panel as Nuke shows it, with the values of a new node. Click any control to see what it does; tabs and sections work as in Nuke.
Bullet Time, what the emitter adds each frame (fuel, heat, smoke, flicker, velocity) and the combustion settings.
Forces on the gas: buoyancy, gravity, wind, vorticity and substeps, plus buoyancy variation and the smoke and fire turbulence.
How the flame front and the smoke edges break up: shredding, disturbance and diffusion.
The look, without re-simulating: output mode, fire colour and brightness, smoke, lighting, depth layers, motion blur and render layers.
GPU, start frame, simulation resolution, closed walls, the memory snapshots and the disk cache.
No control matches.
All controls
Emission25 controls
Bullet Time, what the emitter adds each frame (fuel, heat, smoke, flicker, velocity) and the combustion settings.
- Bullet TimeCheckbox
bulletTime Freezes the simulation at the Freeze at frame while the shading keeps the timeline. Holding a frame costs no simulation time. Ticking it freezes at the current frame. Animate it off to let the simulation go on. Works live and on Read cache.
- Freeze atSlider
bulletFrame The simulation frame Bullet Time holds. Before it the simulation plays normally; from it on it stays still. Animatable.
- reset cacheButton
resetCache Throw away the simulation cache and re-simulate from the start frame. Upstream edits are detected automatically; this is the manual override.
- emit fromMenu
emitChannel Which Source channel drives the emitter (0 = nothing, 1 = full emission).
- emit gainSlider
emitGain Multiplier on the emitter mask before clamping to 0..1.
- smokeSlider
emitSmoke Smoke density added per frame where the mask is 1. Fire makes its own smoke via soot; use this for pure smoke.
- temperatureSlider
emitTemperature Temperature the emitter heats the gas to (~0.9 = fire, 0.3 = warm smoke).
- fuelSlider
emitFuel Fuel added per frame. Fuel burns while hot: flame height = burn time x rise speed.
- flickerSlider
flicker Noise modulation of the emission (0 = steady, 1 = fully broken up).
- flicker sizeSlider
flickerSize Size of the flicker noise in pixels.
- flicker speedSlider
flickerSpeed How fast the flicker noise evolves per frame.
- emit velocity xSlider
emitVelocityX Velocity the emitter pushes gas towards, px/frame (positive = right).
- emit velocity ySlider
emitVelocityY Velocity the emitter pushes gas towards, px/frame (positive = up).
- velocity jitterSlider
emitVelocityJitter Random velocity added at the emitter, px/frame. Breaks the flame into tongues.
- velocity blendSlider
emitVelocityBlend How strongly the emitter imposes its velocity (0 = not at all).
Combustion
- ignition temperatureSlider
ignitionTemperature Fuel burns only above this temperature.
- burn rateSlider
burnRate Fraction of fuel burned per frame while hot. Lower = taller flames.
- heat releaseSlider
heatRelease Temperature added per unit fuel burned.
- sootSlider
sootYield Smoke produced per unit fuel burned.
- flame yieldSlider
flameYield Flame (the visible fire field) produced per unit fuel burned.
- expansionSlider
expansion Gas expansion while burning (pushes the flow outward).
- coolingSlider
cooling Fraction of temperature lost per frame. Lower = taller, longer-lived fire.
- flame decaySlider
flameDecay Fraction of flame lost per frame.
- fuel dissipationSlider
fuelDissipation Fraction of unburnt fuel lost per frame.
- smoke dissipationSlider
smokeDissipation Fraction of smoke lost per frame.
Turbulence17 controls
Forces on the gas: buoyancy, gravity, wind, vorticity and substeps, plus buoyancy variation and the smoke and fire turbulence.
- buoyancySlider
buoyancy Upward acceleration per unit temperature, px/frame^2.
- smoke weightSlider
smokeWeight Downward acceleration per unit smoke density.
- gravitySlider
gravity Constant downward acceleration on everything, px/frame^2.
- wind xSlider
windX Constant drift applied to everything, px/frame (positive = right).
- wind ySlider
windY Constant drift applied to everything, px/frame (positive = up).
- vorticitySlider
vorticity Vorticity confinement: sharpens and sustains swirls. Above ~1 it runs away.
- velocity dampingSlider
velocityDamping Fraction of velocity lost per frame.
- substepsSlider
substeps Simulation steps per frame. 2 is a good default; raise for very fast motion.
Buoyancy variation
- strengthSlider
buoyancyVariation Noise modulation of the buoyancy (0 = uniform lift). Uneven lift splits the rising head into several lobes instead of one clean mushroom cap.
- sizeSlider
buoyancyVariationSize Size of the buoyancy noise in pixels.
- speedSlider
buoyancyVariationSpeed How fast the buoyancy noise evolves per frame.
Smoke turbulence
- strengthSlider
turbulence Large curl-noise force applied where there is smoke / heat.
- sizeSlider
turbulenceSize Size of the large eddies in pixels.
- speedSlider
turbulenceSpeed How fast the large turbulence evolves per frame.
Fire turbulence
Shape21 controls
How the flame front and the smoke edges break up: shredding, disturbance and diffusion.
Shredding
- shreddingSlider
shredding Pushes / pulls the flow along the temperature gradient at the flame front: the licks and tears typical of fire.
- thresholdSlider
shreddingThreshold Temperature the shredding acts around (the flame front).
- widthSlider
shreddingWidth Temperature band around the threshold that is shredded.
- sizeSlider
shreddingSize Size of the push/pull pattern in pixels.
- speedSlider
shreddingSpeed How fast the pattern changes per frame.
Fire disturbance
- strengthSlider
disturbance Random per-block accelerations inside the fire (control field above the threshold).
- block sizeSlider
disturbanceBlockSize Block size in pixels.
- thresholdSlider
disturbanceThreshold Acts where the control field is above this.
- controlMenu
disturbanceControl Field the threshold is tested against.
Smoke disturbance
- strengthSlider
smokeDisturbance Multi-scale random accelerations on the smoke: breaks the smooth swirl outlines into cauliflower.
- block sizeSlider
smokeDisturbanceBlockSize Largest block size in pixels; each octave halves it.
- octavesSlider
smokeDisturbanceOctaves Number of block sizes (each half the previous, half the strength).
- thresholdSlider
smokeDisturbanceThreshold Acts where density is above this.
- cutoffSlider
smokeDisturbanceCutoff Fades out above this density, so only the thin edges are disturbed (0 = everywhere).
Smoke shredding
- strengthSlider
smokeShredding Pushes / pulls the flow along the density gradient at the smoke boundary with a noisy sign: grows fingers and cauliflower on the edges.
- thresholdSlider
smokeShreddingThreshold Density the smoke shredding acts around (the visible edge).
- widthSlider
smokeShreddingWidth Density band around the threshold that is shredded.
- sizeSlider
smokeShreddingSize Size of the push/pull pattern in pixels (the finger spacing).
- speedSlider
smokeShreddingSpeed How fast the pattern changes per frame.
Diffusion
- temperature diffusionSlider
temperatureDiffusion Blurs the temperature field a little each frame. Lower = sharper, higher-frequency shredding; higher = wider, calmer licks.
- flame diffusionSlider
flameDiffusion Blurs the flame field a little each frame.
Shading48 controls
The look, without re-simulating: output mode, fire colour and brightness, smoke, lighting, depth layers, motion blur and render layers.
- outputMenu
output Beauty: fire + smoke, premultiplied. Fire only / Smoke only: the two halves of the beauty (beauty = fire + smoke), for separate grading. Raw fields: R density, G temperature, B flame, A fuel. Velocity: RG = motion in px/frame. Emitter: the mask the solver sees. Normals: smoke pseudo-normals (xyz) + alpha, for relighting. Lighting: R key transmittance, G occlusion, B fire light, A alpha.
- over sourceCheckbox
overSource Composite the result over the Source image.
Fire
- intensitySlider
fireIntensity Brightness of the fire emission (values above 1 clip to white in the viewer).
- kelvin minSlider
fireKelvinMin Colour temperature at temperature 0 (cool tips).
- kelvin maxSlider
fireKelvinMax Colour temperature at temperature 1 (hot core).
- temperature powerSlider
fireTemperaturePower Brightness ~ temperature^power. Higher = brighter core, dimmer tips.
- contrastSlider
fireContrast 0 = soft blob, 1 = hard-edged tongues.
- detailSlider
fireDetail Sub-grid detail noise on the flame.
- color variationSlider
fireColorVariation Detail noise on the colour temperature.
- alphaSlider
fireAlpha How opaque bright fire is in the alpha channel.
Smoke
- opacitySlider
smokeOpacity Opacity per unit smoke density.
- colorColour
smokeColor Smoke albedo. Dark values = black soot (still lit by the fire). Only visible over a plate: Merge over it or tick 'over source'.
- volume depthSlider
smokeDepth Reconstructs a shallow volume with internal shadows from the 2D smoke. 0 keeps the original look; 1 is a thick starting point. Uses opacity, ambient, key, shadow density, scattering and fire light; bypasses the surface form/rim and smoke layer controls.
- depth sizeSlider
smokeDepthSize Depth and internal billow size in pixels. Larger values fill out the smoke and broaden its shadowed folds.
- internal detailSlider
smokeDepthDetail Flowing density variation inside the reconstructed volume. 0 is smooth; higher values add shadowed pockets.
- detailSlider
smokeDetail Sub-grid detail noise on the smoke.
- softnessSlider
smokeSoftness Blur in pixels applied to the density before shading: the sub-grid mixing a 2D grid cannot resolve. Softens the fronts.
- edge break-upSlider
smokeBreakup Displaces the smoke lookup by noise that moves with the flow, in pixels: crisp sub-grid detail on the edges. Applied after the softness blur, so soft fronts still get broken edges.
- break-up sizeSlider
smokeBreakupSize Size of the break-up noise in pixels; two smaller octaves sit under it.
- occludes fireSlider
smokeOccludesFire Absorption of fire within the smoke. Higher values embed the flames more deeply; 0 leaves emission unattenuated.
Lighting
- ambient colorColour
ambientColor Colour of the sky / environment light (comes from above).
- ambientSlider
smokeAmbient Ambient light intensity.
- occlusionSlider
ambientOcclusion Darkens thick regions (dense cores) so thin edges read brighter.
- occlusion radiusSlider
occlusionRadius Blur radius in pixels used as local thickness.
- key colorColour
keyColor Colour of the directional key light.
- keySlider
smokeLight Key light intensity (with self-shadowing).
- key direction xSlider
lightDirectionX Direction the key light comes from (positive = right).
- key direction ySlider
lightDirectionY Direction the key light comes from (positive = up).
- key direction zSlider
lightDirectionZ How much the key light comes from the camera side (0 = grazing, 1 = frontal).
- wrapSlider
lightWrap Wrap lighting: softens the light / shadow terminator (1 = fully wrapped, translucent look).
- shadow densitySlider
smokeShadow Extinction used for self-shadowing towards the key light.
- shadow lengthSlider
smokeShadowLength How far light is traced through the smoke, in pixels.
- scatteringSlider
scattering Multiple-scattering approximation: lets light bleed deeper into the volume (0 = single scattering, hard shadows).
- formSlider
normalStrength How strongly the smoke is shaded as rounded puffs (pseudo-normals). 0 = flat.
- form sizeSlider
normalSoftness Blur radius in pixels for the pseudo-normals: bigger = larger, rounder puffs.
- rimSlider
rim Brightening of thin, lit edges (silver lining).
- light softnessSlider
lightSoftness Blur radius in pixels applied to the computed lighting: scattered light is diffuse.
- fire lightSlider
fireLight How much the fire illuminates the smoke.
- fire light radiusSlider
fireLightRadius Softness / reach of the fire light, in pixels.
Depth layers
- smoke layersSlider
smokeLayers Slices each pixel's optical depth into layers composited front to back: the front is thin, light and lit, deeper layers are darker. 1 = off.
- layer thicknessSlider
layerThickness Optical depth per layer (smaller = the dark core shows through sooner).
- layer darkeningSlider
layerDarkening How much darker the deepest layer is.
- fire layersSlider
fireLayers Additive flame sheets, each with its own detail noise (parallax-like depth).
Motion blur
- shutterSlider
motionBlur Shutter in frames: smoke and fire are blurred along the simulation velocity (0 = off).
- samplesSlider
motionBlurSamples Samples along the shutter.
Detail noise
- sizeSlider
detailSize Size of the sub-grid detail noise in pixels.
- speedSlider
detailSpeed How fast the detail noise evolves on its own per frame (it also moves with the flow).
Layers
- render layersCheckbox
renderLayers Also output the passes as channels: fire, smoke, normals, lighting, velocity (rgba stays the beauty). Layers share the simulation and add shading work; enable them when separate passes are needed.
Sim20 controls
GPU, start frame, simulation resolution, closed walls, the memory snapshots and the disk cache.
- use GPUCheckbox
useGPU Run the simulation and the shading on the GPU through OpenCL (falls back to the CPU if none is available).
- deviceStatus
device Which device the simulation runs on.
- start frameSlider
startFrame The simulation starts empty at this frame.
- sim resolution %Slider
simResolution Simulation grid size as a percentage of the output. 50 is 4x faster than 100; softness and detail noise fill in below that.
- seedSlider
seed Random seed for the noise.
- detail reset periodSlider
detailPeriod Frames before the advected detail texture is refreshed (longer = more stretched wisps).
Closed walls
- leftCheckbox
closedLeft Left edge is a solid wall (otherwise open).
- rightCheckbox
closedRight Right edge is a solid wall (otherwise open).
- bottomCheckbox
closedBottom Bottom edge is a solid wall (otherwise open).
- topCheckbox
closedTop Top edge is a solid wall (otherwise open).
Cache
- snapshot everySlider
cacheInterval Keep a simulation snapshot every N frames so scrubbing only re-simulates from the nearest one.
- cache memory (MB)Slider
cacheMemoryMB Memory budget for snapshots; older ones are thinned out when exceeded.
- always re-simulateCheckbox
alwaysResimulate Re-simulate from the start frame on every render (slow, but always consistent).
- Generate AutofillButton
anrCacheAutoFill Create a fresh node-type/footage_letter_4digits subfolder on every click, then stop. Previous caches are kept.
Fills cache folder with a new, uniquely named folder for this node: inside the folder you typed there or, when it is empty, next to the saved script (save the script first). Every click makes another folder; old caches stay. Nothing is simulated until you build.
- cache folderFile
cacheFolder Required for Build / rebuild cache. Each build writes a new cache_... folder here; nothing is written anywhere else. Use a local fast disk: about 1.2 GB per 100 frames at HD with 50% sim resolution.
- cache to frameSlider
cacheLast Last frame the build simulates (from the start frame). 0 = the end of the timeline.
- after last frameMenu
cacheAfter Frames after the cached range: hold the last frame still, or show nothing.
- build / rebuild cacheButton
buildCache Simulate from the start frame to 'cache to frame' and write every frame into a new folder inside the cache folder, then switch 'read cache' on. Turn off proxy first. Cancel keeps the previous cache.
- read cacheCheckbox
cacheOnly Play the built cache: no simulation, no upstream evaluation, saves and reopens instantly. Shading and output stay live; simulation settings need a rebuild. Before the cached range: nothing. After it: see 'after last frame'.
- cache statusStatus
cacheStatus What the cache holds and what is playing.
Tips
- sim resolution % at 50 simulates about four times faster than 100, and softness and detail noise fill in the look. Raise it for crisp close-ups.
- Smoke colour only shows against a plate: judge color in the Smoke section with the result merged over your background, or with over source ticked.
- output > Emitter shows the mask the solver sees. Use it to check the emit from channel and emit gain.
- Fire only and Smoke only add up to the beauty, so you can grade them separately and Plus them back together.
- volume depth gives the smoke internal shadows and a thicker look; 0 keeps the flat 2D look.
- Closed walls on Sim turn image edges into solid walls, for smoke that pools against a ceiling or spreads along a floor.
- shutter in the Motion blur section blurs fire and smoke along their own motion; 0 turns it off.
- Tick render layers for fire, smoke, normals, lighting and velocity channels beside the beauty, and write all channels to an EXR to keep them.
- Upstream roto edits are detected by themselves. reset cache on Emission forces a fresh simulation from the start frame if you ever need one.
Good to know
- The simulation runs on the GPU when use GPU is on, and device shows which one. Without a usable GPU it runs on the CPU, more slowly.
- Cache folder: nothing is written to disk until cache folder is set; there is no default location. Each build writes a new folder inside it and older builds are kept. Allow about 1.2 GB per 100 frames at HD with 50% sim resolution, on a fast local disk.
- With read cache on, shading and output stay live, but emission, motion and sim settings need build / rebuild cache again; cache status says when the cache is out of date. Before the cached range the node shows nothing; after it, after last frame holds the last frame or shows nothing.
- With read cache on, a missing cache frame plays the nearest earlier frame with a warning in the GUI; in a farm or terminal render it stops the render with an error instead.
- Bullet Time freezes the simulation at Freeze at (ticking it uses the current frame). Before that frame it plays normally; from it on the fire holds still, costs no simulation time and keeps its motion blur. Animate Bullet Time off to let it go on: the fire continues as if it had never stopped, so it jumps to where it would be on that frame. It works live and on a read cache.
- Cancelling a cache build keeps the previous cache; only the new, unfinished folder is removed.
Works with
ANR 3D Fire SimpleReal 3D fire and smoke from the alpha of any image: one node that simulates on the GPU and renders a lit volume you can orbit, place and match to your shot.
ANR Interactive LightLights an element with footage of a fire, lightning or a screen, through its normals and depth, with shadows from its own shape or from smoke.
ANR Matte CreatorDraw a box, click a point or type a word on one frame, and the AI model mattes that subject through the whole shot, with clean hair and soft edges.
ANR GlowA soft, layered bloom around bright lights and highlights, with control over its size, spread and colour, and a matte input to choose which lights glow.Something unclear or missing? Write to [email protected].