Particles
Spawn clouds of points — dust, sparks, debris, sand, snow — and let forces, age, and collisions carry them.
Particles are the simplest and most flexible simulation in DNA. You feed in a set of points, and the simulation.particle node moves them every frame under gravity, force fields, and (optionally) collisions with each other. Because particles are just points, they're cheap to make millions of and easy to dress up afterwards — as sprites, impostors, or instanced geometry.
Emitting particles
Particles start as points. Anything that makes points can feed the sim — a sop.scatter spreading points over a surface, an imported point cloud, or a primitive's vertices. Wire those points into the Particle Sim node and they become the live particle set.
To emit continuously over time, drive your point source so it adds new points each frame, then carry the simulation across frames in a feedback loop (see Loops & feedback). DNA keeps the solver state alive between frames automatically, so particles persist, accumulate, and age rather than restarting every cook.
Each particle carries attributes you can read and animate — including its age, velocity, and position. Use these in an Expression to fade, colour, or scale particles over their lifetime. See Attributes.
Forces and motion
On its own, the Particle Sim applies gravity and integrates motion. To push particles around, wire in a simulation.force_field:
Directional — a steady push, like wind.
Point — pull toward or blast away from a position (attractor / repulsor).
Vortex — swirl around an axis.
Turbulence — procedural noise for natural, drifting motion.
Drag — slow particles down over time.
Each force has a falloff (none, linear, quadratic, or smooth) so its influence can fade with distance. Forces stack, so you can combine wind plus turbulence plus a gentle vortex for organic movement. See Forces & collisions.
You can also drive particles with a field — for example, a vector volume baked from curl noise — which acts as a spatially varying wind. See Fields & sampling.
Self-collision: dust vs sand
The Particle Sim has one defining switch — self-collision — that changes its whole character:
Off — particles ignore each other and are purely force-driven. This is the look for dust, sparks, smoke wisps, and debris: they overlap freely and flow like a gas.
On (the default) — particles push apart with contact and friction, behaving like a granular material. This is sand, snow, gravel, and grain — particles pile up, form slopes, and settle into heaps.
Self-collision is on by default, so a fresh Particle Sim behaves like sand. Turn it off for free-flowing dust and spark effects.
Particles also collide with colliders in the scene — a Physics Collider surface, a ground plane, or a Distance Field volume used as a collision boundary — so your sand can pour onto geometry and your sparks can bounce off walls.
| Parameter | Type | Default |
|---|---|---|
input | OneOf([CollectionOf(Points), CollectionOf(Geometry)]) | — |
self_collision | Boolean | true |
particle_radius | Number | 0.050 |
friction | Number | 0.500 |
restitution | Number | 0.300 |
cohesion | Number | 0 |
damping | Number | 0.010 |
strength | Number | 1 |
Rendering particles
Particles are points, so by default you'll see them as dots. To give them substance, dress them after the sim:
Sprites — textured points that always face the camera. Great for sparks, dust motes, and soft puffs. Cheap and fast.
Impostors — points that hold a continuously re-baked 3D look, so they read as solid even up close.
Instanced geometry — copy a real shape (a pebble, a snowflake) onto every particle.
See Sprites, impostors & billboards and Rasterizing for the full picture.
See also
Simulation — all simulation types
Forces & collisions — force fields and colliders in depth
Fluid & smoke — when particles should flow like liquid or gas
Loops & feedback — keeping a sim alive over time
Points — the data particles are made of
Sprites, impostors & billboards — making particles visible